AWS Lambda

Guía para desarrolladores

 AWS Lambda Guía para desarrolladores

AWS Lambda: Guía para desarrolladores

Copyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,
in any manner that is likely to cause confusion among customers, or in any manner that disparages or discredits
Amazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may not
be affiliated with, connected to, or sponsored by Amazon.
 AWS Lambda Guía para desarrolladores

Table of Contents
¿Qué es AWS Lambda? ...................................................................................................................... 1
¿Cuándo debo usar AWS Lambda? .............................................................................................. 1
¿Es la primera vez que usa AWS Lambda? ................................................................................... 2
Introducción ....................................................................................................................................... 3
Creación de una función .............................................................................................................. 3
Uso de Designer ................................................................................................................ 4
Invocación de la función de Lambda ..................................................................................... 4
Editor de código ......................................................................................................................... 6
Uso de archivos y carpetas .................................................................................................. 7
Trabajar con código ............................................................................................................ 8
Trabajar en modo de pantalla completa ............................................................................... 11
Trabajar con preferencias ................................................................................................... 11
AWS CLI ................................................................................................................................. 12
Requisitos previos ............................................................................................................. 12
Creación del rol de ejecución ............................................................................................. 12
Creación de la función ....................................................................................................... 14
Liste las funciones de Lambda de su cuenta ......................................................................... 16
Recuperar una función Lambda. ......................................................................................... 16
Eliminación ...................................................................................................................... 17
Conceptos ............................................................................................................................... 17
Función ........................................................................................................................... 17
Tiempo de ejecución ......................................................................................................... 17
Evento ............................................................................................................................. 18
Simultaneidad ................................................................................................................... 18
Trigger ............................................................................................................................ 18
Características .......................................................................................................................... 19
Modelo de programación .................................................................................................... 19
Paquete de implementación ............................................................................................... 21
Capas ............................................................................................................................. 21
Escalado ......................................................................................................................... 21
Controles de simultaneidad ................................................................................................ 22
Invocación asíncrona ......................................................................................................... 24
Mapeos de origen de eventos ............................................................................................ 25
Destinos .......................................................................................................................... 26
Proyectos de funciones ...................................................................................................... 27
Plantillas de aplicaciones ................................................................................................... 28
Herramientas ............................................................................................................................ 28
AWS Command Line Interface ............................................................................................ 28
Modelo de aplicación sin servidor de AWS ........................................................................... 28
CLI de SAM ..................................................................................................................... 29
Herramientas para crear código .......................................................................................... 29
Límites .................................................................................................................................... 30
Permisos ......................................................................................................................................... 32
Rol de ejecución ....................................................................................................................... 32
Creación de un rol de ejecución en la consola de IAM ............................................................ 34
Administración de roles con la API de IAM ........................................................................... 34
Políticas administradas para características de Lambda .......................................................... 35
Políticas basadas en recursos .................................................................................................... 36
Concesión de acceso a las funciones a los servicios de AWS .................................................. 38
Concesión de acceso a las funciones a otras cuentas ............................................................ 38
Concesión de acceso a las capas a otras cuentas ................................................................. 40
Limpieza de políticas basadas en recursos ........................................................................... 40
Políticas de usuario ................................................................................................................... 41
Desarrollo de funciones ..................................................................................................... 41

iii
 AWS Lambda Guía para desarrolladores

Desarrollo y uso de capas ................................................................................................. 44

Roles entre cuentas .......................................................................................................... 45
Recursos y condiciones ............................................................................................................. 45
Funciones ........................................................................................................................ 47
Mapeos de origen de eventos ............................................................................................ 48
Capas ............................................................................................................................. 48
Límites de permisos .................................................................................................................. 49
Administración de funciones ............................................................................................................... 51
Consola de configuración ........................................................................................................... 52
Variables de entorno ................................................................................................................. 54
Variables de entorno de tiempo de ejecución ........................................................................ 56
Proteger variables de entorno ............................................................................................. 57
Configuración de variables de entorno con la API de Lambda .................................................. 58
Código de muestra y plantillas ............................................................................................ 59
Simultaneidad ........................................................................................................................... 59
Configuración de la simultaneidad reservada ........................................................................ 60
Configuración de simultaneidad aprovisionada ....................................................................... 62
Configuración de simultaneidad con la API de Lambda ........................................................... 65
Versiones ................................................................................................................................ 68
Administración de versiones con la API de Lambda ............................................................... 69
Uso de versiones .............................................................................................................. 69
Políticas de recursos ......................................................................................................... 70
Alias ....................................................................................................................................... 70
Administración de alias con la API de Lambda ...................................................................... 71
Uso de alias .................................................................................................................... 71
Políticas de recursos ......................................................................................................... 72
Configuración de direccionamiento de alias ........................................................................... 72
Capas ..................................................................................................................................... 74
Configuración de una función para usar capas ...................................................................... 74
Administración de capas .................................................................................................... 75
Inclusión de dependencias de biblioteca en una capa ............................................................. 77
Permisos de capa ............................................................................................................. 78
Red ........................................................................................................................................ 78
Rol de ejecución y permisos de usuario ............................................................................... 79
Configuración del acceso a la Amazon VPC con la API de Lambda .......................................... 80
Acceso a Internet y a los servicios para funciones conectadas a la VPC .................................... 80
Ejemplos de configuraciones de VPC .................................................................................. 81
Base de datos .......................................................................................................................... 81
Aplicación de muestra ....................................................................................................... 82
Etiquetas ................................................................................................................................. 83
Uso de etiquetas con AWS CLI .......................................................................................... 85
Requisitos de las claves y los valores de las etiquetas ........................................................... 86
Invocar funciones .............................................................................................................................. 87
Invocación síncrona .................................................................................................................. 88
Invocación asíncrona ................................................................................................................. 89
Configuración de la gestión de errores para la invocación asincrónica ....................................... 92
Configuración de destinos para invocación asincrónica ........................................................... 92
API de configuración de invocación asincrónica ..................................................................... 94
Colas de mensajes fallidos ................................................................................................. 95
Mapeo de orígenes de eventos ................................................................................................... 97
Estados de función .................................................................................................................. 101
Escalado de funciones ............................................................................................................. 102
Control de errores ................................................................................................................... 107
SDK de Mobile para Android .................................................................................................... 109
Tutorial .......................................................................................................................... 110
Código de muestra .......................................................................................................... 115
Tiempos de ejecución de Lambda. .................................................................................................... 118

iv
 AWS Lambda Guía para desarrolladores

Contexto de ejecución ............................................................................................................. 120

Política de soporte del tiempo de ejecución ................................................................................ 120
Tiempos de ejecución personalizados ........................................................................................ 121
Uso de un tiempo de ejecución personalizado ..................................................................... 122
Creación de un tiempo de ejecución personalizado .............................................................. 122
Interfaz de tiempo de ejecución ................................................................................................. 124
Siguiente invocación ........................................................................................................ 124
Respuesta de la invocación .............................................................................................. 125
Error de invocación ......................................................................................................... 125
Error de inicialización ....................................................................................................... 126
Tutorial: Tiempo de ejecución personalizado ............................................................................... 126
Requisitos previos ........................................................................................................... 126
Crear una función ........................................................................................................... 127
Crear una capa ............................................................................................................... 128
Actualización de la función ............................................................................................... 129
Actualización del tiempo de ejecución ................................................................................ 130
Uso compartido de la capa ............................................................................................... 130
Eliminación ..................................................................................................................... 131
Aplicaciones de Lambda .................................................................................................................. 132
Administración de aplicaciones .................................................................................................. 132
Monitorización de aplicaciones .......................................................................................... 133
Paneles personalizados de monitorización .......................................................................... 133
Tutorial: Crear una aplicación ................................................................................................... 135
Requisitos previos ........................................................................................................... 136
Creación de una aplicación .............................................................................................. 136
Invocación de la función ................................................................................................... 136
Agregar un recurso de AWS ............................................................................................. 137
Actualizar el límite de permisos ......................................................................................... 138
Actualizar el código de la función ...................................................................................... 138
Pasos siguientes ............................................................................................................. 140
Solución de problemas ..................................................................................................... 140
Eliminación ..................................................................................................................... 141
– de ejemplo: Procesamiento de errores ..................................................................................... 141
Arquitectura y estructura de eventos .................................................................................. 142
Instrumentación con AWS X-Ray ....................................................................................... 143
Plantilla de AWS CloudFormation y recursos adicionales ....................................................... 144
Implementaciones continuas ..................................................................................................... 145
Plantilla de AWS SAM de Lambda de ejemplo .................................................................... 146
Casos de uso ......................................................................................................................... 147
Ejemplo 1: Amazon S3 envía eventos e invoca una función de Lambda ................................... 147
Ejemplo 2: AWS Lambda obtiene los eventos desde un flujo de Kinesis e invoca una función de
Lambda ......................................................................................................................... 148
Prácticas recomendadas .......................................................................................................... 149
Código de la función ....................................................................................................... 149
Función de configuración .................................................................................................. 150
Alarmas y métricas .......................................................................................................... 151
Invocaciones con eventos de flujo ..................................................................................... 151
Uso de otros servicios ..................................................................................................................... 153
Balanceador de carga de aplicaciones ....................................................................................... 155
Alexa ..................................................................................................................................... 156
API Gateway .......................................................................................................................... 157
Permisos ........................................................................................................................ 159
Administración de errores con una API de API Gateway ........................................................ 161
Elegir un tipo de API ....................................................................................................... 162
Aplicaciones de ejemplo ................................................................................................... 163
Tutorial .......................................................................................................................... 164
Código de muestra .......................................................................................................... 172

v
 AWS Lambda Guía para desarrolladores

Proyecto de microservicio ................................................................................................. 175

Plantilla de muestra ......................................................................................................... 176
AWS CloudTrail ...................................................................................................................... 177
Tutorial .......................................................................................................................... 178
Código de muestra .......................................................................................................... 183
Eventos de CloudWatch ........................................................................................................... 185
Tutorial .......................................................................................................................... 186
Plantilla de muestra ......................................................................................................... 188
Programación de expresiones ........................................................................................... 189
Amazon CloudWatch Logs ....................................................................................................... 190
AWS CloudFormation .............................................................................................................. 191
CloudFront ............................................................................................................................. 193
AWS CodeCommit .................................................................................................................. 194
CodePipeline .......................................................................................................................... 195
Permisos ........................................................................................................................ 197
Tutorial .......................................................................................................................... 197
Amazon Cognito ..................................................................................................................... 203
AWS Config ........................................................................................................................... 203
Amazon DynamoDB ................................................................................................................ 204
Permisos de rol de ejecución ............................................................................................ 206
Configuración de una secuencia como un origen de eventos ................................................. 206
API de mapeo de origen de eventos .................................................................................. 207
Control de errores ........................................................................................................... 209
Métricas de Amazon CloudWatch ...................................................................................... 210
Tutorial .......................................................................................................................... 210
Código de muestra .......................................................................................................... 214
Plantilla de muestra ......................................................................................................... 217
Amazon ElastiCache ................................................................................................................ 218
Requisitos previos ........................................................................................................... 219
Creación del rol de ejecución ............................................................................................ 219
Crear un clúster de ElastiCache. ....................................................................................... 219
Cree un paquete de implementación. ................................................................................. 220
Creación de la función Lambda ......................................................................................... 220
Pruebe la función Lambda. ............................................................................................... 221
Amazon EC2 .......................................................................................................................... 221
Permisos ........................................................................................................................ 222
Tutorial: Instancias de spot ............................................................................................... 222
AWS IoT ................................................................................................................................ 231
AWS IoT Events ..................................................................................................................... 232
Kinesis ................................................................................................................................... 233
Configurar su flujo de datos y función. ............................................................................... 235
Permisos de rol de ejecución ............................................................................................ 235
Configuración de una secuencia como un origen de eventos ................................................. 236
API de mapeo de origen de eventos .................................................................................. 237
Control de errores ........................................................................................................... 239
Métricas de Amazon CloudWatch ...................................................................................... 240
Tutorial .......................................................................................................................... 240
Código de muestra .......................................................................................................... 243
Plantilla de muestra ......................................................................................................... 247
Kinesis Data Firehose .............................................................................................................. 248
Amazon Lex ........................................................................................................................... 249
Amazon RDS ......................................................................................................................... 249
Tutorial: Amazon RDS ..................................................................................................... 250
Eventos de Amazon S3 ........................................................................................................... 254
Tutorial .......................................................................................................................... 255
Código de muestra .......................................................................................................... 261
Plantilla de muestra ......................................................................................................... 267

vi
 AWS Lambda Guía para desarrolladores

Operaciones por lotes de Amazon S3 ........................................................................................ 268

Invocar funciones Lambda desde operaciones por lotes de Amazon S3 ................................... 269
Amazon SES .......................................................................................................................... 270
Amazon SNS .......................................................................................................................... 271
Tutorial .......................................................................................................................... 273
Código de muestra .......................................................................................................... 275
Amazon SQS ......................................................................................................................... 277
Escalado y procesamiento ................................................................................................ 279
Configuración de una cola para el uso con Lambda ............................................................. 279
Permisos de rol de ejecución ............................................................................................ 280
Configuración de una cola como origen de eventos .............................................................. 280
API de mapeo de origen de eventos .................................................................................. 207
Tutorial .......................................................................................................................... 281
Código de muestra .......................................................................................................... 284
Plantilla de muestra ......................................................................................................... 287
Uso de [Link] ............................................................................................................................... 289
Controlador ............................................................................................................................ 290
Controladores asincrónicos ............................................................................................... 291
Controladores no asincrónicos .......................................................................................... 292
Paquete de implementación ...................................................................................................... 292
Actualización de una función sin dependencias .................................................................... 293
Actualización de una función con dependencias adicionales .................................................. 293
Contexto ................................................................................................................................ 294
Registro ................................................................................................................................. 295
Visualización de registros en la Consola de administración de AWS ........................................ 297
Mediante la AWS CLI ...................................................................................................... 297
Eliminación de registros ................................................................................................... 299
Errores .................................................................................................................................. 299
Rastreo .................................................................................................................................. 300
Uso de Python ................................................................................................................................ 302
Controlador ............................................................................................................................ 304
Paquete de implementación ...................................................................................................... 304
Requisitos previos ........................................................................................................... 305
Actualización de una función sin dependencias .................................................................... 305
Actualización de una función con dependencias adicionales .................................................. 306
Con un entorno virtual ..................................................................................................... 307
Contexto ................................................................................................................................ 308
Registro ................................................................................................................................. 309
Visualización de registros en la Consola de administración de AWS ........................................ 311
Mediante la AWS CLI ...................................................................................................... 311
Eliminación de registros ................................................................................................... 312
Biblioteca de registro ....................................................................................................... 313
Errores .................................................................................................................................. 313
Rastreo .................................................................................................................................. 314
Uso de Ruby .................................................................................................................................. 317
Controlador ............................................................................................................................ 318
Paquete de implementación ...................................................................................................... 319
Actualización de una función sin dependencias .................................................................... 320
Actualización de una función con dependencias adicionales .................................................. 320
Contexto ................................................................................................................................ 321
Registro ................................................................................................................................. 322
Visualización de registros en la Consola de administración de AWS ........................................ 311
Mediante la AWS CLI ...................................................................................................... 311
Eliminación de registros ................................................................................................... 312
Errores .................................................................................................................................. 326
Uso de Java ................................................................................................................................... 328
Paquete de implementación ...................................................................................................... 329

vii
 AWS Lambda Guía para desarrolladores

Compilación de un paquete de implementación con Gradle ................................................... 331

Compilación de un paquete de implementación con Maven ................................................... 332
Carga de un paquete de implementación con la API de Lambda ............................................. 333
Carga de un paquete de implementación con AWS SAM ...................................................... 334
Controlador ............................................................................................................................ 335
Elección de los tipos de entrada y salida ............................................................................ 336
Interfaces de controlador .................................................................................................. 337
Ejemplo de código del controlador ..................................................................................... 338
Contexto ................................................................................................................................ 339
Contexto en aplicaciones de ejemplo ................................................................................. 341
Registro ................................................................................................................................. 341
Visualización de registros en la Consola de administración de AWS ........................................ 343
Mediante la AWS CLI ...................................................................................................... 343
Eliminación de registros ................................................................................................... 345
Registro avanzado con Log4j 2 y SLF4J ............................................................................. 345
Código de registro de ejemplo .......................................................................................... 347
Errores .................................................................................................................................. 347
Ver la salida de errores ................................................................................................... 348
Descripción de los tipos y orígenes de errores .................................................................... 350
Administración de errores en los clientes ............................................................................ 351
Administración de errores en otros servicios de AWS ........................................................... 351
Administración de errores en aplicaciones de ejemplo ........................................................... 352
Rastreo .................................................................................................................................. 352
Habilitación del seguimiento activo con la API de Lambda ..................................................... 354
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 354
Seguimiento en las aplicaciones de ejemplo ........................................................................ 355
Tutorial: IDE de Eclipse ........................................................................................................... 356
Requisitos previos ........................................................................................................... 356
Creación y compilación de un proyecto .............................................................................. 357
Uso de Go ..................................................................................................................................... 359
Paquete de implementación ...................................................................................................... 359
Creación de un paquete de implementación en Windows ...................................................... 360
Controlador ............................................................................................................................ 360
Controlador de funciones de Lambda con tipos estructurados ................................................ 361
Uso del estado global ...................................................................................................... 363
Contexto ................................................................................................................................ 364
Acceso a la información del contexto de invocación ............................................................. 364
Registro ................................................................................................................................. 365
Visualización de registros en la Consola de administración de AWS ........................................ 367
Mediante la AWS CLI ...................................................................................................... 367
Eliminación de registros ................................................................................................... 369
Errores .................................................................................................................................. 369
Rastreo .................................................................................................................................. 369
Instalación del SDK de X-Ray para Go ............................................................................... 369
Configuración del SDK de X-Ray para Go .......................................................................... 370
Creación de un subsegmento ........................................................................................... 370
Captura ......................................................................................................................... 370
Rastreo de solicitudes HTTP ............................................................................................ 370
Variables de entorno ............................................................................................................... 371
Trabajar con C# .............................................................................................................................. 372
Paquete de implementación ...................................................................................................... 372
CLI de .NET Core ........................................................................................................... 373
AWS Toolkit for Visual Studio ........................................................................................... 376
Controlador ............................................................................................................................ 378
Control de flujos .............................................................................................................. 378
Control de tipos de datos estándar .................................................................................... 379
Signaturas para los controladores ...................................................................................... 380

viii
 AWS Lambda Guía para desarrolladores

Serialización de las funciones de Lambda ........................................................................... 380

Restricciones del controlador de funciones de Lambda ......................................................... 381
Uso de async en funciones C# con AWS Lambda ................................................................ 381
Contexto ................................................................................................................................ 382
Registro ................................................................................................................................. 383
Visualización de registros en la Consola de administración de AWS ........................................ 385
Mediante la AWS CLI ...................................................................................................... 385
Eliminación de registros ................................................................................................... 386
Errores .................................................................................................................................. 387
Trabajar con PowerShell .................................................................................................................. 390
Entorno de desarrollo .............................................................................................................. 390
Paquete de implementación ...................................................................................................... 391
Controlador ............................................................................................................................ 392
Devolución de datos ........................................................................................................ 393
Contexto ................................................................................................................................ 393
Registro ................................................................................................................................. 394
Visualización de registros en la Consola de administración de AWS ........................................ 395
Mediante la AWS CLI ...................................................................................................... 395
Eliminación de registros ................................................................................................... 397
Errores .................................................................................................................................. 397
Monitorización ................................................................................................................................. 399
Consola de administración ........................................................................................................ 400
Métricas de funciones .............................................................................................................. 400
Uso de métricas de invocación ......................................................................................... 401
Uso de métricas de desempeño ........................................................................................ 402
Uso de métricas de simultaneidad ..................................................................................... 402
Registros de CloudWatch ......................................................................................................... 403
Uso de AWS X-Ray ................................................................................................................ 404
Rastreo de aplicaciones basadas en Lambda con AWS X-Ray ............................................... 405
Emisión de segmentos de rastro desde una función de Lambda ............................................. 406
El demonio de AWS X-Ray en el entorno de Lambda ........................................................... 407
Uso de variables de entorno para comunicarse con AWS X-Ray ............................................. 407
Ejemplos de rastros de Lambda en la consola de AWS X-Ray ............................................... 408
CloudTrail .............................................................................................................................. 409
Información de AWS Lambda en CloudTrail ........................................................................ 410
Descripción de las entradas de los archivos de registro de AWS Lambda ................................. 411
Uso de CloudTrail para rastrear invocaciones de funciones ................................................... 412
Seguridad ...................................................................................................................................... 413
Protección de los datos ............................................................................................................ 413
Cifrado en tránsito ........................................................................................................... 414
Cifrado en reposo ........................................................................................................... 414
Identity and Access Management .............................................................................................. 415
Público .......................................................................................................................... 415
Autenticación con identidades ........................................................................................... 415
Administración de acceso mediante políticas ....................................................................... 417
Funcionamiento de AWS Lambda con IAM ......................................................................... 419
Ejemplos de políticas basadas en identidad ........................................................................ 419
Solución de problemas ..................................................................................................... 421
Validación de la conformidad .................................................................................................... 423
Resiliencia .............................................................................................................................. 423
Seguridad de la infraestructura .................................................................................................. 424
Configuración y análisis de vulnerabilidades ................................................................................ 425
Solución de problemas ..................................................................................................................... 426
Implementación ....................................................................................................................... 426
Invocación .............................................................................................................................. 428
Ejecución ............................................................................................................................... 430
Redes .................................................................................................................................... 431

ix
 AWS Lambda Guía para desarrolladores

Versiones ....................................................................................................................................... 433

Actualizaciones anteriores ........................................................................................................ 441
Referencia de la API ....................................................................................................................... 447
Actions .................................................................................................................................. 447
AddLayerVersionPermission .............................................................................................. 449
AddPermission ................................................................................................................ 452
CreateAlias ..................................................................................................................... 456
CreateEventSourceMapping .............................................................................................. 460
CreateFunction ............................................................................................................... 466
DeleteAlias ..................................................................................................................... 475
DeleteEventSourceMapping .............................................................................................. 477
DeleteFunction ................................................................................................................ 481
DeleteFunctionConcurrency .............................................................................................. 483
DeleteFunctionEventInvokeConfig ...................................................................................... 485
DeleteLayerVersion ......................................................................................................... 487
DeleteProvisionedConcurrencyConfig ................................................................................. 489
GetAccountSettings ......................................................................................................... 491
GetAlias ......................................................................................................................... 493
GetEventSourceMapping .................................................................................................. 496
GetFunction .................................................................................................................... 500
GetFunctionConcurrency .................................................................................................. 503
GetFunctionConfiguration ................................................................................................. 505
GetFunctionEventInvokeConfig .......................................................................................... 511
GetLayerVersion ............................................................................................................. 514
GetLayerVersionByArn ..................................................................................................... 517
GetLayerVersionPolicy ..................................................................................................... 520
GetPolicy ....................................................................................................................... 522
GetProvisionedConcurrencyConfig ..................................................................................... 524
Invoke ........................................................................................................................... 527
InvokeAsync ................................................................................................................... 532
ListAliases ...................................................................................................................... 534
ListEventSourceMappings ................................................................................................. 537
ListFunctionEventInvokeConfigs ......................................................................................... 540
ListFunctions .................................................................................................................. 543
ListLayers ...................................................................................................................... 546
ListLayerVersions ............................................................................................................ 548
ListProvisionedConcurrencyConfigs .................................................................................... 551
ListTags ......................................................................................................................... 554
ListVersionsByFunction .................................................................................................... 556
PublishLayerVersion ........................................................................................................ 559
PublishVersion ................................................................................................................ 563
PutFunctionConcurrency ................................................................................................... 570
PutFunctionEventInvokeConfig .......................................................................................... 573
PutProvisionedConcurrencyConfig ...................................................................................... 577
RemoveLayerVersionPermission ........................................................................................ 580
RemovePermission .......................................................................................................... 582
TagResource .................................................................................................................. 584
UntagResource ............................................................................................................... 586
UpdateAlias .................................................................................................................... 588
UpdateEventSourceMapping ............................................................................................. 592
UpdateFunctionCode ....................................................................................................... 598
UpdateFunctionConfiguration ............................................................................................. 605
UpdateFunctionEventInvokeConfig ..................................................................................... 614
Data Types ............................................................................................................................ 617
AccountLimit ................................................................................................................... 619
AccountUsage ................................................................................................................ 620
AliasConfiguration ............................................................................................................ 621

x
 AWS Lambda Guía para desarrolladores

AliasRoutingConfiguration ................................................................................................. 623

Concurrency ................................................................................................................... 624
DeadLetterConfig ............................................................................................................ 625
DestinationConfig ............................................................................................................ 626
Environment ................................................................................................................... 627
EnvironmentError ............................................................................................................ 628
EnvironmentResponse ..................................................................................................... 629
EventSourceMappingConfiguration ..................................................................................... 630
FunctionCode ................................................................................................................. 633
FunctionCodeLocation ...................................................................................................... 634
FunctionConfiguration ...................................................................................................... 635
FunctionEventInvokeConfig ............................................................................................... 640
Layer ............................................................................................................................. 642
LayersListItem ................................................................................................................ 643
LayerVersionContentInput ................................................................................................. 644
LayerVersionContentOutput .............................................................................................. 645
LayerVersionsListItem ...................................................................................................... 646
OnFailure ....................................................................................................................... 648
OnSuccess ..................................................................................................................... 649
ProvisionedConcurrencyConfigListItem ............................................................................... 650
TracingConfig ................................................................................................................. 652
TracingConfigResponse ................................................................................................... 653
VpcConfig ...................................................................................................................... 654
VpcConfigResponse ........................................................................................................ 655
Errores de los certificados cuando se utiliza un SDK .................................................................... 655
AWS Glossary ................................................................................................................................ 657

xi
 AWS Lambda Guía para desarrolladores
¿Cuándo debo usar AWS Lambda?

¿Qué es AWS Lambda?

AWS Lambda es un servicio informático que permite ejecutar código sin aprovisionar ni administrar
servidores. AWS Lambda ejecuta el código solo cuando es necesario, y se escala de manera automática,
pasando de pocas solicitudes al día a miles por segundo. Solo se paga el tiempo de computación que se
consume; no hay ningún cargo mientras el código no se ejecuta. Con AWS Lambda, puede ejecutar código
para prácticamente cualquier tipo de aplicación o servicio de backend, y sin que se requiera ningún tipo de
administración. AWS Lambda ejecuta el código en una infraestructura informática de alta disponibilidad y
ejecuta la administración integral de los recursos informáticos, incluido el mantenimiento del servidor y del
sistema operativo, el aprovisionamiento de capacidad y el escalado automático, así como la monitorización
y los registros. Lo único que tiene que hacer es suministrar el código en uno de los lenguajes que admite
AWS Lambda (p. 118).

Puede utilizar AWS Lambda para ejecutar código como respuesta a eventos, por ejemplo, cambios en
los datos de un bucket de Amazon S3 o de una tabla de Amazon DynamoDB; para ejecutar código como
respuesta a solicitudes HTTP utilizando Amazon API Gateway; o invocar código utilizando las llamadas a
las API realizadas a través de los SDK de AWS. Con estas funciones, puede utilizar Lambda para crear
fácilmente disparadores de procesamiento de datos para servicios de AWS como Amazon S3 y Amazon
DynamoDB, procesar datos de streaming almacenados en Kinesis o crear un backend propio que opere
con el nivel de seguridad, desempeño y escala de AWS.

También puede crear aplicaciones sin servidor compuestas por funciones activadas por eventos
e implementarlas automáticamente utilizando CodePipeline y AWS CodeBuild. Para obtener más
información, consulte Aplicaciones de AWS Lambda (p. 132).

¿Cuándo debo usar AWS Lambda?

AWS Lambda es una plataforma de computación ideal para muchas situaciones, siempre que el código
de las aplicaciones pueda escribirse en los lenguajes admitidos por AWS Lambda y que pueda ejecutarse
dentro del entorno de tiempo de ejecución estándar de AWS Lambda y de los recursos proporcionados por
Lambda.

Cuando se utiliza AWS Lambda, solo es necesario preocuparse por el código. AWS Lambda administra
la flota de computación, que ofrece una combinación equilibrada de memoria, CPU, red y otros recursos.
Esto es a cambio de flexibilidad, lo que significa que no se puede iniciar sesión en instancias de
computación ni personalizar el sistema operativo ni los tiempos de ejecución proporcionado. Estas
restricciones permiten que AWS Lambda realice actividades operativas y administrativas en su nombre,
como son el aprovisionamiento de capacidad, la monitorización del estado de la flota, la aplicación de
parches de seguridad, la implementación del código, y la monitorización y el registro de las funciones de
Lambda.

Si necesita administrar sus propios recursos informáticos, Amazon Web Services también ofrece otros
servicios informáticos para satisfacer sus necesidades.

• El servicio Amazon Elastic Compute Cloud (Amazon EC2) ofrece flexibilidad y una amplia variedad de
tipos de instancias de EC2 para elegir. Ofrece la posibilidad de personalizar los sistemas operativos,
la pila completa de software y la configuración de red y de seguridad, pero el usuario es responsable
de aprovisionar la capacidad, monitorizar el estado y el desempeño de la flota y utilizar las zonas de
disponibilidad para aumentar la tolerancia a errores.
• Elastic Beanstalk ofrece un servicio fácil de utilizar para implementar y escalar aplicaciones en Amazon
EC2, en el que se mantiene la propiedad y el control total sobre las instancias EC2 subyacentes.

1
 AWS Lambda Guía para desarrolladores
¿Es la primera vez que usa AWS Lambda?

Lambda es un servicio de alta disponibilidad. Para obtener más información, consulte el acuerdo de nivel
de servicios de AWS Lambda.

¿Es la primera vez que usa AWS Lambda?

Si es la primera vez que utiliza AWS Lambda, le recomendamos que lea las siguientes secciones en orden:

1. Lea la información general del producto y vea el vídeo introductorio para conocer los ejemplos de casos
de uso. Estos recursos están disponibles en la página web deAWS Lambda .
2. Realice el ejercicio de introducción basado en la consola. El ejercicio ofrece instrucciones para crear
y probar su primera función de Lambda mediante la consola. También obtendrá información sobre
el modelo de programación y otros conceptos de Lambda. Para obtener más información, consulte
Introducción a AWS Lambda (p. 3).
3. Lea la sección Implementación de aplicaciones con AWS Lambda (p. 132) de esta guía. Esta sección
presenta varios componentes de AWS Lambda con los que va a trabajar para crear una experiencia
integral.

Además del ejercicio de introducción, puede examinar distintos casos de uso, cada uno de los cuales
dispone de un tutorial que presenta un escenario de ejemplo. Puede realizar tutoriales específicos acordes
con las necesidades de su aplicación (por ejemplo, si desea que la invocación de la función de Lambda
sea controlada por eventos o bajo demanda). Para obtener más información, consulte Uso de AWS
Lambda con otros servicios (p. 153).

2
 AWS Lambda Guía para desarrolladores
Creación de una función

Introducción a AWS Lambda

Para empezar a utilizar AWS Lambda, utilice la consola de Lambda para crear una función. En unos
minutos, puede crear una función, invocarla y ver registros, métricas y datos de rastreo.
Note

Para poder utilizar Lambda y otros servicios de AWS, necesita disponer de una cuenta de AWS.
Si no dispone de una cuenta, visite [Link] y, a continuación, elija Create an AWS
Account (Crear una cuenta de AWS). Para obtener instrucciones detalladas, consulte Creación y
activación de una cuenta de AWS.
Como práctica recomendada, también debe crear un usuario de AWS Identity and Access
Management (IAM) con permisos de administrador y utilizarlo para todo el trabajo que no requiera
el uso de credenciales raíz. Cree una contraseña para el acceso a la consola y claves de acceso
para utilizar herramientas de línea de comandos. Consulte Creación del primer grupo y usuario
administrador de IAM en la Guía del usuario de IAM para obtener instrucciones.

Puede crear funciones en la consola de Lambda, con un conjunto de herramientas IDE, con herramientas
de línea de comandos o con SDK. La consola de Lambda proporciona un editor de código (p. 6) para
lenguajes no compilados que permite modificar y probar el código con rapidez. La AWS CLI (p. 12)
ofrece acceso directo a la API de Lambda para la configuración avanzada y casos de uso de
automatización.

Temas
• Creación de una función de Lambda con la consola (p. 3)
• Creación de funciones mediante el editor de la consola de AWS Lambda (p. 6)
• Uso de AWS Lambda con AWS Command Line Interface (p. 12)
• Conceptos de AWS Lambda (p. 17)
• Características de AWS Lambda (p. 19)
• Herramientas para usar AWS Lambda (p. 28)
• Límites de AWS Lambda (p. 30)

Creación de una función de Lambda con la consola

En este ejercicio de introducción, creará una función de Lambda utilizando la consola de AWS Lambda.
A continuación, deberá invocar la función de Lambda de forma manual utilizando los datos del evento de
muestra. AWS Lambda ejecuta la función de Lambda y devuelve los resultados. Seguidamente, podrá
verificar los resultados de la ejecución, incluidos los registros creados por la función de Lambda y varias
métricas de CloudWatch.

Para crear una función de Lambda

1. Abra la consola de AWS Lambda.

2. Seleccione Create a function (Crear una función).
3. En Function name (Nombre de función), escriba my-function.

3
 AWS Lambda Guía para desarrolladores
Uso de Designer

4. Elija Create function (Crear función).

Lambda crea una función de [Link] y un rol de ejecución que concede a la función permiso para cargar
registros. Lambda asume el rol de ejecución cuando se invoca la función y lo utiliza para crear credenciales
para el SDK de AWS y para leer datos de los orígenes de eventos.

Uso de Designer
En Designer (Diseñador) se muestra información general de su función y de sus recursos anteriores y
posteriores. Puede usarlo para configurar desencadenadores, capas y destinos.

Elija my-función en el diseñador para volver al código y la configuración de la función. Para los lenguajes
de scripting, Lambda incluye código de muestra que devuelve una respuesta de operación correcta. Puede
editar el código de la función con el editor AWS Cloud9 integrado, siempre y cuando el código fuente no
supere el límite de 3 MB.

Invocación de la función de Lambda

Invoque la función de Lambda utilizando los datos del evento de muestra que se proporcionan en la
consola.

Para invocar una función

1. En la esquina superior derecha, elija Test (Probar).

2. En la página Configure test event (Configurar evento de prueba), elija Create new test event (Crear
nuevo evento de prueba) y en Event template (Plantilla de eventos) deje la opción predeterminada
Hello World (Hola, mundo). Escriba un nombre en Event name (Nombre del evento) y examine la
siguiente plantilla de eventos de ejemplo:

{
"key3": "value3",
"key2": "value2",
"key1": "value1"

4
 AWS Lambda Guía para desarrolladores
Invocación de la función de Lambda

Si lo desea, puede modificar las claves y los valores en el código JSON de muestra, pero no cambie
la estructura del evento. Si realiza alguna modificación en las claves o los valores, debe actualizar el
código de muestra según sea necesario.
3. Elija Create (Crear) y después Test (Prueba). Cada usuario puede crear hasta 10 eventos de prueba
por función. Dichos eventos de prueba no están disponibles para otros usuarios.
4. AWS Lambda ejecuta la función en su nombre. El handler de la función de Lambda recibe el evento
de muestra y, a continuación, lo procesa.
5. Si la ejecución se realiza correctamente, puede ver los resultados en la consola.

• La sección Execution result (Resultado de la ejecución) muestra el estado de ejecución como

succeeded (correcta) y también muestra los resultados de la ejecución de la función devueltos por la
instrucción return.
• La sección Summary (Resumen) muestra la información principal proporcionada en la sección Log
output (Resultado del registro) (la línea REPORT del registro de ejecución).
• La sección Log output (Resultado del registro) muestra los registros que genera AWS Lambda
para cada ejecución. Estos son los registros que escribe la función de CloudWatch en Lambda. La
consola de AWS Lambda muestra estos registros para su comodidad.

Tenga en cuenta que el enlace Click here (Haga clic aquí) muestra los registros en la consola de
CloudWatch. A continuación, la función añade registros a Amazon CloudWatch en el grupo de
registros correspondiente a la función de Lambda.
6. Ejecute la función de Lambda varias veces para recopilar algunas métricas que podrá ver en el
siguiente paso.
7. Elija Monitoring (Monitorización). Esta página muestra gráficos de las métricas que Lambda envía a
CloudWatch.

5
 AWS Lambda Guía para desarrolladores
Editor de código

Para obtener más información acerca de estos gráficos, consulte Monitorización de funciones en la
consola de AWS Lambda (p. 400).

Creación de funciones mediante el editor de la

consola de AWS Lambda
El editor de código de la consola de AWS Lambda le permite escribir, probar y ver los resultados de
ejecución del código de sus funciones de Lambda.

El editor de código incluye una barra de menús, ventanas y un panel de edición.

Para obtener una lista de lo que hacen los comandos, consulte la Referencia de los comandos de menú
en la Guía del usuario de AWS Cloud9. Tenga en cuenta que algunos de los comandos que se indican en
dicha referencia no están disponibles en el editor de código.

6
 AWS Lambda Guía para desarrolladores
Uso de archivos y carpetas

Temas
• Uso de archivos y carpetas (p. 7)
• Trabajar con código (p. 8)
• Trabajar en modo de pantalla completa (p. 11)
• Trabajar con preferencias (p. 11)

Uso de archivos y carpetas

Puede utilizar la ventana Environment del editor de código para crear, abrir y administrar los archivos para
su función.

Para mostrar u ocultar la ventana Environment, elija el botón Environment. Si la ventana Environment no
está visible, elija Window, Environment en la barra de menús.

Para abrir un único archivo y mostrar su contenido en el panel de edición, haga doble clic en el archivo en
la ventana Environment.

Para abrir varios archivos y mostrar su contenido en el panel de edición, elija los archivos en la ventana
Environment. Haga clic con el botón derecho en la selección y elija Open.

Para crear un nuevo archivo, proceda del modo siguiente:

• En la ventana Environment, haga clic con el botón derecho en la carpeta en la que desee almacenar
el nuevo archivo y, a continuación, elija New File. Escriba el nombre y la extensión del archivo y, a
continuación, pulse Enter.

7
 AWS Lambda Guía para desarrolladores
Trabajar con código

• Elija File, New File en la barra de menús. Cuando esté listo para guardar el archivo, elija File, Save o
File, Save As en la barra de menús. A continuación, use el cuadro de diálogo Save As que aparece para
asignar un nombre al archivo y elegir dónde debe almacenarse.
• En la barra de botones de la pestaña del panel de edición, elija el botón + y, a continuación, elija New
File. Cuando esté listo para guardar el archivo, elija File, Save o File, Save As en la barra de menús. A
continuación, use el cuadro de diálogo Save As que aparece para asignar un nombre al archivo y elegir
dónde debe almacenarse.

Para crear una nueva carpeta, haga clic con el botón derecho en la carpeta en la ventana Environment
donde desee almacenar la nueva carpeta y, a continuación, elija New Folder. Escriba el nombre de la
carpeta y pulse Enter.

Para guardar un archivo, con el archivo abierto y su contenido visible en el panel de edición, seleccione
File, Save en la barra de menús.

Para cambiar el nombre de un archivo o carpeta, haga clic con el botón derecho en el archivo o carpeta en
la ventana Environment. Escriba el nuevo nombre y pulse Enter.

Para eliminar archivos o carpetas, seleccione los archivos o carpetas en la ventana Environment. Haga clic
con el botón derecho en la selección y elija Delete. A continuación, confirme la eliminación eligiendo Yes
(para una única selección) o Yes to All.

Para cortar, copiar, pegar o duplicar archivos o carpetas, seleccione los archivos o carpetas en la ventana
Environment. Haga clic con el botón derecho en la selección y, a continuación, elija Cut, Copy, Paste o
Duplicate, respectivamente.

Para contraer carpetas, elija el icono del engranaje en la ventana Environment y, a continuación, elija
Collapse All Folders.

Para mostrar u ocultar archivos, elija el icono del engranaje en la ventana Environment y, a continuación,
elija Show Hidden Files.

Trabajar con código

Utilice el panel de edición del editor de código para ver y escribir código.

8
 AWS Lambda Guía para desarrolladores
Trabajar con código

Trabajar con los botones de la pestaña

Utilice la barra de botones de la pestaña para seleccionar, ver y crear archivos.

Para mostrar el contenido de un archivo abierto, lleve a cabo alguna de las siguientes operaciones:

• Elija la pestaña del archivo.

• Elija el botón de menú desplegable de la barra de botones de la pestaña y, a continuación, elija el
nombre del archivo.

Para cerrar un archivo abierto, realice una de las siguientes operaciones:

• Elija el icono X de la pestaña del archivo.

• Elija la pestaña del archivo. A continuación, elija el botón de menú desplegable de la barra de botones
de la pestaña y elija Close Pane.

Para cerrar varios archivos abiertos, elija el menú desplegable de la barra de botones de la pestaña y, a
continuación, elija Close All Tabs in All Panes o Close All But Current Tab según sea necesario.

9
 AWS Lambda Guía para desarrolladores
Trabajar con código

Para crear un nuevo archivo, elija el botón + de la barra de botones de la pestaña y, a continuación, elija
New File. Cuando esté listo para guardar el archivo, elija File, Save o File, Save As en la barra de menús.
A continuación, use el cuadro de diálogo Save As que aparece para asignar un nombre al archivo y elegir
dónde debe almacenarse.

Trabajar con la barra de estado

Utilice la barra de estado para moverse rápidamente a una línea del archivo activo y cambiar el modo en
que se muestra el código.

Para moverse rápidamente a una línea del archivo activo, elija el selector de líneas, escriba el número de
línea al que desea ir y, a continuación, pulse Enter.

Para cambiar el esquema de color del código en el archivo activo, elija el selector de esquemas de color
del código y, a continuación, elija el nuevo código esquema de color.

Para cambiar en el archivo activo si se utilizan tabuladores o espacios suaves, el tamaño del tabulador o si
desea convertir espacios en tabuladores, elija el selector de espacios y tabuladores y, a continuación, elija
la nueva configuración.

10
 AWS Lambda Guía para desarrolladores
Trabajar en modo de pantalla completa

Para cambiar si se muestran u ocultan los caracteres invisibles o el margen interno, el emparejamiento
automático de corchetes o comillas, el ajuste de las líneas o el tamaño de la fuente para todos los archivos,
elija el icono de engranaje y, a continuación, elija la nueva configuración.

Trabajar en modo de pantalla completa

Puede ampliar el editor de código para disponer de más espacio para trabajar con el código.

Para ampliar el editor de código hasta los bordes de la ventana del navegador web, seleccione el botón
Toggle fullscreen en la barra de menús.

Para restablecer el editor de código a su tamaño original, seleccione de nuevo el botón Toggle fullscreen.

En modo de pantalla completa, se muestran opciones adicionales en la barra de menús: Save (Guardar) y
Test (Prueba). Elija Save para guardar el código de la función. Elija Test o Configure Events para crear o
editar los eventos de prueba de la función.

Trabajar con preferencias

Puede cambiar distintas opciones de configuración del editor de código, como las pistas y advertencias de
programación que se muestran, el comportamiento de plegado de código, el comportamiento de la función
autocompletar del código, etc.

11
 AWS Lambda Guía para desarrolladores
AWS CLI

Para cambiar la configuración del editor de código, elija el icono de engranaje Preferences de la barra de
menús.

Para obtener una lista de lo que hacen las opciones, consulte las siguientes referencias en la Guía del
usuario de AWS Cloud9.

• Project Setting Changes You Can Make

• User Setting Changes You Can Make

Tenga en cuenta que algunas de las opciones que se indican en estas referencias no están disponibles en
el editor de código.

Uso de AWS Lambda con AWS Command Line

Interface
Puede usar el AWS Command Line Interface para administrar funciones y otros recursos de AWS Lambda.
El AWS CLI utiliza el AWS SDK for Python (Boto) para interactuar con el API de Lambda. Puede usarlo
para aprender sobre el API y aplicar ese conocimiento a la construcción de aplicaciones que usen Lambda
con el SDK de AWS.

En este tutorial, administrará e invocará funciones de Lambda con el AWS CLI.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Este tutorial utiliza la AWS Command Line Interface (AWS CLI) para llamar a las operaciones de la API
de servicio. Para instalar la AWS CLI, consulte Instalación de la CLI de AWS en la AWS Command Line
Interface Guía del usuario.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos
de AWS. Para crear un rol de ejecución con la CLI de AWS, utilice el comando create-role.

12
 AWS Lambda Guía para desarrolladores
Creación del rol de ejecución

$ aws iam create-role --role-name lambda-ex --assume-role-policy-document [Link]

[Link]
{
"Role": {
"Path": "/",
"RoleName": "lambda-ex",
"RoleId": "AROAQFOXMPL6TZ6ITKWND",
"Arn": "arn:aws:iam::123456789012:role/lambda-ex",
"CreateDate": "2020-01-17T23:19:12Z",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "sts:AssumeRole"
}
]
}
}
}

El archivo [Link] es un archivo JSON en el directorio actual que define la política de

confianza del rol. Esta política de confianza permite a Lambda utilizar los permisos del rol dando al servicio
principal [Link] permiso para llamar a la acción AssumeRole de AWS Security Token
Service.

Example [Link]

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "sts:AssumeRole"
}
]
}

También puede especificar la política de confianza insertada. Los requisitos de las cuotas de escape en la
cadena JSON varía según el shell.

$ aws iam create-role --role-name lambda-ex --assume-role-policy-document

'{"Version": "2012-10-17","Statement": [{ "Effect": "Allow", "Principal": {"Service":
"[Link]"}, "Action": "sts:AssumeRole"}]}'

Para añadir permisos al rol, use el comando attach-policy-to-role. Empiece añadiendo la política
administrada AWSLambdaBasicExecutionRole.

$ aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/

service-role/AWSLambdaBasicExecutionRole

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

13
 AWS Lambda Guía para desarrolladores
Creación de la función

Creación de la función
En el siguiente ejemplo, se registran los valores de las variables de entorno y el objeto de evento.

Example [Link]

[Link] = async function(event, context) {

[Link]("ENVIRONMENT VARIABLES\n" + [Link]([Link], null, 2))
[Link]("EVENT\n" + [Link](event, null, 2))
return [Link]
}

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function. Reemplace el texto resaltado en el
ARN de rol por su ID de cuenta.

$ aws lambda create-function --function-name my-function \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-ex
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-ex",
"Handler": "[Link]",
"CodeSha256": "FpFMvUhayLkOoVBpNuNiIVML/tuGv2iJQ7t0yWVTU8c=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "PassThrough"
},
"RevisionId": "88ebe1e1-bfdf-4dc3-84de-3017268fa1ff",
...
}

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d

14
 AWS Lambda Guía para desarrolladores
Creación de la función

START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST

"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,

15
 AWS Lambda Guía para desarrolladores
Liste las funciones de Lambda de su cuenta

"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:

26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Liste las funciones de Lambda de su cuenta

Ejecute el siguiente comando list-functions de la AWS CLI para obtener una lista de las funciones
que ha creado.

$ aws lambda list-functions --max-items 10

{
"Functions": [
{
"FunctionName": "cli",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-ex",
"Handler": "[Link]",
...
},
{
"FunctionName": "random-error",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:random-error",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
...
},
...
],
"NextToken": "eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxMH0="
}

Como respuesta, Lambda devuelve una lista de hasta 10 funciones. Si hay más funciones, NextToken
proporciona un marcador que puede utilizar en la siguiente solicitud list-functions. El siguiente
comando list-functions de la AWS CLI es un ejemplo de uso del parámetro --starting-token.

$ aws lambda list-functions --max-items 10 --starting-

token eyJNYXJrZXIiOiBudWxsLCAiYm90b190cnVuY2F0ZV9hbW91bnQiOiAxMH0=

Recuperar una función Lambda.

El comando get-function de la CLI de Lambda devuelve a Lambda los metadatos de la función y una
URL prefirmada que puede usar para descargar el paquete de implementación de la función.

$ aws lambda get-function --function-name my-function

{
"Configuration": {
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-ex",
"CodeSha256": "FpFMvUhayLkOoVBpNuNiIVML/tuGv2iJQ7t0yWVTU8c=",

16
 AWS Lambda Guía para desarrolladores
Eliminación

"Version": "$LATEST",
"TracingConfig": {
"Mode": "PassThrough"
},
"RevisionId": "88ebe1e1-bfdf-4dc3-84de-3017268fa1ff",
...
},
"Code": {
"RepositoryType": "S3",
"Location": "[Link]
snapshots/123456789012/my-function-4203078a-b7c9-4f35-..."
}
}

Para obtener más información, consulte GetFunction (p. 500).

Eliminación
Ejecute el siguiente comando delete-function para eliminar la función my-function.

$ aws lambda delete-function --function-name my-function

Borre el rol de IAM que creó en la consola de IAM. Para obtener información acerca de cómo eliminar un
rol, consulte Eliminación de roles o perfiles de instancia en la Guía del usuario de IAM.

Conceptos de AWS Lambda

Con AWS Lambda, se ejecutan funciones para procesar eventos. Puede enviar eventos a la función
invocándola con la API de Lambda o configurando un servicio o recurso de AWS para invocarla.

Conceptos
• Función (p. 17)
• Tiempo de ejecución (p. 17)
• Evento (p. 18)
• Simultaneidad (p. 18)
• Trigger (p. 18)

Función
Una función es un recurso que puede invocar para ejecutar el código en AWS Lambda. Una función
tiene código que procesa eventos y un elemento de tiempo de ejecución que transfiere las solicitudes y
las respuestas entre Lambda y el código de la función. Debe proporcionar el código y puede utilizar los
runtimes proporcionados o crear los suyos propios.

Para obtener más información, consulte Administración de funciones de AWS Lambda (p. 51).

Tiempo de ejecución
Los runtimes de Lambda permiten la ejecución de funciones en distintos lenguajes en el mismo entorno
de ejecución básico. Puede configurar la función para utilizar un tiempo de ejecución que se ajuste a su

17
 AWS Lambda Guía para desarrolladores
Evento

lenguaje de programación. El runtime se encuentra entre el servicio Lambda y el código de su función,

y retransmite eventos de invocación, información de contexto y respuestas entre los dos. Puede utilizar
tiempos de ejecución proporcionados por Lambda, o bien crear los suyos propios.

Para obtener más información, consulte Tiempos de ejecución de AWS Lambda. (p. 118).

Evento
Un evento es un documento con formato JSON que contiene datos para que una función los procese. El
tiempo de ejecución de Lambda convierte el evento en un objeto y lo pasa al código de la función. Cuando
se invoca una función, se determina la estructura y el contenido del evento.

Example Evento personalizado: datos del tiempo

{
"TemperatureK": 281,
"WindKmh": -3,
"HumidityPct": 0.55,
"PressureHPa": 1020
}

Cuando un servicio de AWS invoca una función, el servicio define la forma del evento.

Example Evento de servicio: notificación de Amazon SNS

{
"Records": [
{
"Sns": {
"Timestamp": "2019-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "Hello from SNS!",
...

Para obtener más información sobre los eventos de los servicios de AWS, consulte Uso de AWS Lambda
con otros servicios (p. 153).

Simultaneidad
La simultaneidad es el número de solicitudes que la función atiende en un momento dado. Cuando se
invoca la función, Lambda aprovisiona una instancia para procesar el evento. Cuando el código de la
función termina de ejecutarse, puede encargarse de otra solicitud. Si la función se invoca de nuevo
mientras se sigue procesando una solicitud, se aprovisiona otra instancia, lo que aumenta la simultaneidad
de la función.

La simultaneidad está sujeta a límites en el nivel de región. También puede configurar funciones
individuales para limitar su simultaneidad o para garantizar que puedan alcanzar un nivel específico de
simultaneidad. Para obtener más información, consulte Administración de la simultaneidad para una
función Lambda (p. 59).

Trigger
Un desencadenador es un recurso o configuración que invoca una función Lambda. Entre estos se
incluyen servicios de AWS que se hayan configurado para invocar una función, aplicaciones que usted

18
 AWS Lambda Guía para desarrolladores
Características

desarrolle y mapeos de orígenes de eventos. Un mapeo de origen de eventos es un recurso de Lambda

que lee elementos de un flujo o una cola e invoca una función.

Para obtener más información, consulte Invocación de funciones de AWS Lambda (p. 87) y Uso de
AWS Lambda con otros servicios (p. 153).

Características de AWS Lambda

AWS Lambda proporciona una consola de administración y una API para administrar e invocar funciones.
Proporciona tiempos de ejecución que admiten un conjunto estándar de características para que pueda
cambiar fácilmente de un lenguaje a otro o de una plataforma a otra en función de sus necesidades.
Además de funciones, también puede crear versiones, alias, capas y tiempos de ejecución personalizados.

Características
• Modelo de programación (p. 19)
• Paquete de implementación (p. 21)
• Capas (p. 21)
• Escalado (p. 21)
• Controles de simultaneidad (p. 22)
• Invocación asíncrona (p. 24)
• Mapeos de origen de eventos (p. 25)
• Destinos (p. 26)
• Proyectos de funciones (p. 27)
• Plantillas de aplicaciones (p. 28)

Modelo de programación
Los detalles del proceso de creación varían de unos tiempos de ejecución a otros, pero todos comparten
un modelo de programación común que define la interfaz entre el código y el código de tiempo
de ejecución. Puede indicar al runtime qué método debe ejecutar definiendo un controlador en la
configuración de la función; el runtime ejecutará dicho método. El runtime se pasa en forma de objetos al
controlador que contiene el evento de invocación y el contexto, como el nombre de la función y el ID de la
solicitud.

Cuando el controlador termina de procesar el primer evento, el runtime le envía otro. La clase de la
función permanece en la memoria, por lo que se pueden reutilizar los clientes y las variables declarados
fuera del método del controlador en código de inicialización. Para ahorrar tiempo de procesamiento en
eventos posteriores, cree recursos reutilizables como clientes AWS SDK durante la inicialización. Una vez
inicializada, cada instancia de su función puede procesar miles de solicitudes.

La inicialización se factura como parte de la duración de la primera invocación procesada por una instancia
de su función. Cuando se habilita el seguimiento de X-Ray (p. 404), el motor de ejecución registra
subsegmentos separados para la inicialización y la ejecución.

19
 AWS Lambda Guía para desarrolladores
Modelo de programación

La función también tiene acceso al almacenamiento local en el directorio /tmp. Las instancias de su
función que están atendiendo solicitudes permanecen activas durante unas horas antes de reciclarse.

El runtime captura la salida de registro de la función y la envía a Amazon CloudWatch Logs. Además de
registrar la salida de su función, el tiempo de ejecución también registra las entradas cuando se inicia y
finaliza la ejecución. Esto incluye un registro de informe con el ID de solicitud, la duración facturada, la
duración de inicialización y otros detalles. Si la función genera un error, el runtime devuelve ese error al
invocador.
Note

El registro está sujeto a los límites de CloudWatch Logs. Los datos de registro se pueden perder
debido a una limitación controlada o, en algunos casos, cuando se detiene una instancia de su
función.

Para obtener una introducción práctica sobre estos conceptos en su lenguaje de programación preferido,
consulte los siguientes capítulos.

• Creación de funciones de Lambda con [Link] (p. 289)

• Creación de funciones de Lambda con Python (p. 302)
• Creación de funciones Lambda con Ruby (p. 317)
• Creación de funciones de Lambda con Java (p. 328)
• Creación de funciones de Lambda con Go (p. 359)
• Creación de funciones de Lambda con C# (p. 372)
• Creación de funciones de Lambda con PowerShell (p. 390)

Lambda escala la función ejecutando instancias adicionales a medida que aumenta la demanda y
deteniendo instancias a medida que disminuye la demanda. A menos que se indique lo contrario, las

20
 AWS Lambda Guía para desarrolladores
Paquete de implementación

solicitudes entrantes pueden procesarse de forma desordenada o simultánea. Almacene el estado de

la aplicación en otros servicios y no confíe en que las instancias de la función tengan una larga vida
útil. Utilice el almacenamiento local y los objetos de nivel de clase para aumentar el rendimiento, pero
mantenga al mínimo el tamaño del paquete de implementación y la cantidad de datos que transfiere al
entorno de ejecución.

Paquete de implementación
El código de la función se compone de scripts o programas compilados y sus dependencias. Al crear
funciones en la consola de Lambda o con un conjunto de herramientas, el cliente crea un archivo ZIP del
código denominado “paquete de implementación”. A continuación, el cliente envía el paquete al servicio
Lambda. Al administrar funciones con la API de Lambda, con las herramientas de línea de comandos
o con los SDK, debe crear el paquete de implementación. También es necesario crear un paquete de
implementación manualmente para lenguajes compilados y para añadir dependencias a la función.

Si desea obtener instrucciones específicas del lenguaje, consulte los temas siguientes.

• Paquete de implementación AWS Lambda en [Link] (p. 292)

• Paquete de implementación de AWS Lambda en Python (p. 304)
• Paquete de implementación de AWS Lambda en Ruby (p. 319)
• Paquete de implementación AWS Lambda en Java (p. 329)
• AWS Lambda Paquete de implementación en Go (p. 359)
• AWS Lambda Paquete de implementación en C# (p. 372)
• AWS Lambda Paquete de implementación en PowerShell (p. 391)

Capas
Las capas de Lambda son un mecanismo de distribución para bibliotecas, runtimes personalizados y otras
dependencias de la función. Las capas le permiten administrar su código de función en desarrollo con
independencia del código invariable y los recursos que utiliza. Puede configurar la función para utilizar las
capas que cree, las capas que proporciona AWS, o las capas de otros clientes de AWS.

Para obtener más información, consulte Capas de AWS Lambda (p. 74).

Escalado
Lambda administra la infraestructura que ejecuta el código, escalándola automáticamente en respuesta a
las solicitudes entrantes. Cuando la función se invoca a mayor velocidad de la que una sola instancia de su
función puede procesar eventos, Lambda amplía la capacidad ejecutando instancias adicionales. Cuando
el tráfico disminuye, las instancias inactivas se bloquean o detienen. Solo paga por el tiempo que la función
inicia o procesa eventos.

21
 AWS Lambda Guía para desarrolladores
Controles de simultaneidad

Para obtener más información, consulte Escalado de funciones de AWS Lambda (p. 102).

Controles de simultaneidad
Utilice la configuración de simultaneidad para asegurarse de que sus aplicaciones de producción tengan
alta disponibilidad y capacidad de respuesta. Para evitar que una función utilice demasiada simultaneidad
y para reservar una parte de la simultaneidad disponible de su cuenta para una función, utilice la
simultaneidad reservada. La simultaneidad reservada divide el grupo de simultaneidad disponible en
subconjuntos. Una función con simultaneidad reservada solo usa simultaneidad desde su grupo dedicado.

22
 AWS Lambda Guía para desarrolladores
Controles de simultaneidad

Para permitir a las funciones que se escalen sin fluctuaciones en la latencia, utilice la simultaneidad
aprovisionada. Para las funciones que tardan mucho tiempo en inicializarse o que requieren latencia
extremadamente baja para todas las invocaciones, la concurrencia aprovisionada le permite preinicializar
instancias de su función y mantenerlas ejecutándose en todo momento. Lambda se integra con Auto
Scaling de aplicaciones para admitir el escalado automático para simultaneidad aprovisionada basada en
la utilización.

23
 AWS Lambda Guía para desarrolladores
Invocación asíncrona

Para obtener más información, consulte Administración de la simultaneidad para una función
Lambda (p. 59).

Invocación asíncrona
Al invocar una función, puede optar por invocarla de forma síncrona o asíncrona. Con invocación
síncrona (p. 88), espere la función para procesar el evento y devolver una respuesta. Con
invocación asíncrona, Lambda pone en cola el evento para su procesamiento y devuelve una respuesta
inmediatamente.

24
 AWS Lambda Guía para desarrolladores
Mapeos de origen de eventos

Para las invocaciones asíncronas, Lambda maneja reintentos si la función devuelve un error o está
limitada. Para personalizar este comportamiento, puede configurar las opciones de gestión de errores en
una función, versión o alias. También puede configurar Lambda para que envíe eventos que hayan fallado
en el procesamiento a una cola de mensajes fallidos o para que envíe un registro de cualquier invocación a
un destino (p. 26).

Para obtener más información, consulte Invocación asíncrona (p. 89).

Mapeos de origen de eventos

Para procesar elementos de una transmisión o una cola, puede crear un mapeo de origen de
eventos (p. 97). Un mapeo de origen de eventos es un recurso en Lambda que lee los elementos de
una cola de Amazon SQS, una transmisión de Amazon Kinesis o una transmisión de Amazon DynamoDB
y los envía a su función en lotes. Cada evento que su función procesa puede contener cientos o miles de
elementos.

25
 AWS Lambda Guía para desarrolladores
Destinos

Los mapeos de origen de eventos mantienen una cola local de elementos no procesados y manejan los
reintentos si la función devuelve un error o está limitada. Puede configurar un mapeo de origen de eventos
para personalizar el comportamiento de lotes y el control de errores, o para enviar un registro de elementos
que no se han podido procesar a un destino (p. 26).

Para obtener más información, consulte Mapeo de origen de eventos de AWS Lambda (p. 97).

Destinos
Un destino es un recurso de AWS que recibe registros de invocación para una función. Para invocación
asíncrona (p. 24), puede configurar Lambda para que envíe registros de invocación a una cola, un
tema, una función o un bus de eventos. Puede configurar destinos separados para las invocaciones
exitosas y los eventos que no se procesaron correctamente. El registro de invocación contiene detalles
sobre el evento, la respuesta de la función y el motivo por el que se ha enviado el registro.

26
 AWS Lambda Guía para desarrolladores
Proyectos de funciones

Para los mapeos de origen de eventos (p. 25) que leen desde secuencias, puede configurar Lambda
para que envíe un registro de lotes que no se han procesado correctamente a una cola o tema. Un registro
de error para un mapeo de origen de evento contiene metadatos sobre el lote y apunta a los elementos de
la secuencia.

Para obtener más información, consulte Configuración de destinos para invocación asincrónica (p. 92) y
las secciones de control de errores de Uso de AWS Lambda con Amazon DynamoDB (p. 204) y Uso de
AWS Lambda con Amazon Kinesis (p. 233).

Proyectos de funciones
Al crear una función en la consola de Lambda, puede optar por comenzar desde cero, utilizar un proyecto
o implementar una aplicación desde el AWS Serverless Application Repository. Un proyecto proporciona
código de muestra que indica cómo usar Lambda con un servicio de AWS o una aplicación de terceros
popular. Los proyectos incluyen preajustes de configuración de código de muestra y funciones para los
tiempos de ejecución de [Link] y Python.

27
 AWS Lambda Guía para desarrolladores
Plantillas de aplicaciones

Los proyectos se proporcionan para su uso bajo la licencia Creative Commons Zero . Solo están
disponibles en la consola de Lambda.

Plantillas de aplicaciones
Puede utilizar la consola de Lambda para crear una aplicación con una canalización de entrega continua.
Las plantillas de aplicación de la consola de Lambda incluyen código para una o varias funciones,
una plantilla de aplicación que define funciones y recursos de AWS compatibles y una plantilla de
infraestructura que define una canalización de AWS CodePipeline. La canalización tiene etapas de
compilación e implementación que se ejecutan cada vez que inserta cambios en el repositorio Git incluido.

Las plantillas de aplicación se proporcionan para su uso bajo la licencia MIT sin atribución . Solo están
disponibles en la consola de Lambda.

Para obtener más información, consulte Creación de una aplicación con entrega continua en la consola de
Lambda (p. 135).

Herramientas para usar AWS Lambda

Además de la consola de Lambda, puede utilizar las siguientes herramientas para administrar e invocar
recursos de Lambda.

Herramientas
• AWS Command Line Interface (p. 28)
• Modelo de aplicación sin servidor de AWS (p. 28)
• CLI de SAM (p. 29)
• Herramientas para crear código (p. 29)

AWS Command Line Interface

Instale la AWS Command Line Interface para administrar y utilizar funciones de Lambda desde la línea
de comandos. En los tutoriales de esta guía se utiliza la AWS CLI, que tiene comandos para todas las
acciones de la API de Lambda. Alguna funcionalidad no está disponible en la consola de Lambda y solo se
puede obtener acceso a ella con la AWS CLI o el AWS SDK.

Para configurar la AWS CLI, consulte los siguientes temas en la AWS Command Line Interface Guía del
usuario.

• Configuración inicial de la AWS Command Line Interface

• Configuración de la AWS Command Line Interface

Para verificar que la AWS CLI está configurada correctamente, ejecute el comando list-functions
para ver una lista de las funciones Lambda en la región actual.

$ aws lambda list-functions

Modelo de aplicación sin servidor de AWS

AWS SAM es una extensión del lenguaje de plantillas de AWS CloudFormation que le permite definir
aplicaciones sin servidor en un nivel superior. Condensa tareas comunes como la creación de roles
de funciones, lo que facilita la escritura de plantillas. AWS SAM está directamente apoyado por AWS
CloudFormation, e incluye funcionalidad adicional mediante AWS CLI y AWS SAM CLI.

28
 AWS Lambda Guía para desarrolladores
CLI de SAM

Para obtener más información acerca de las plantillas de AWS SAM, consulte Aspectos básicos sobre las
plantillas de AWS SAM en la Guía para desarrolladores de Modelo de aplicación sin servidor de AWS.

CLI de SAM
La CLI de AWS SAM es una herramienta de línea de comandos independiente que puede utilizar para
administrar y probar aplicaciones de AWS SAM. Además de los comandos para cargar artefactos y lanzar
pilas de AWS CloudFormation que también están disponibles en la AWS CLI, la CLI de SAM proporciona
comandos adicionales para validar plantillas y ejecutar aplicaciones de forma local en un contenedor de
Docker.

Para configurar la CLI de AWS SAM, consulte Instalación de la CLI de AWS SAM en la Guía para
desarrolladores de Modelo de aplicación sin servidor de AWS.

Herramientas para crear código

Puede escribir el código de la función de Lambda en los lenguajes admitidos por AWS Lambda. Para ver
una lista de los lenguajes admitidos, consulte Tiempos de ejecución de AWS Lambda. (p. 118). Existen
herramientas para la creación de código, como la consola de AWS Lambda el IDE de Eclipse y el IDE de
Visual Studio. Sin embargo, las herramientas y las opciones disponibles dependen de lo siguiente:

• El lenguaje que elija para escribir el código de la función de Lambda.

• Las bibliotecas que utilice en el código. El tiempo de ejecución de AWS Lambda proporciona algunas de
las bibliotecas, y el usuario debe cargar las bibliotecas adicionales que utilice.

En la siguiente tabla se muestran los lenguajes y las herramientas y opciones disponibles que puede
utilizar.

Lenguaje Herramientas y opciones para crear código

[Link] • Consola de AWS Lambda

• Visual Studio, con el complemento del IDE (consulte AWS Lambda
Support in Visual Studio)
• Su propio entorno de desarrollo

Java • Eclipse, con conjunto de herramientas AWS para Eclipse (consulte

Uso de AWS Lambda con conjunto de herramientas AWS para
Eclipse)
• IntelliJ, con el AWS Toolkit for IntelliJ
• Su propio entorno de desarrollo

C# • Visual Studio, con el complemento del IDE (consulte AWS Lambda

Support in Visual Studio)
• .NET Core (consulte la guía de instalación de .NET Core)
• Su propio entorno de desarrollo

Python • Consola de AWS Lambda

• PyCharm, con el AWS Toolkit for PyCharm
• Su propio entorno de desarrollo

Ruby • Consola de AWS Lambda

• Su propio entorno de desarrollo

Go • Su propio entorno de desarrollo

29
 AWS Lambda Guía para desarrolladores
Límites

Lenguaje Herramientas y opciones para crear código

PowerShell • Su propio entorno de desarrollo

• PowerShell Core 6.0 (consulte Installing PowerShell Core)
• .NET Core 2.1 SDK (consulte Descargas de .NET)
• Módulo AWSLambdaPSCore (consulte PowerShell Gallery)

Límites de AWS Lambda

AWS Lambda Limita la cantidad de recursos informáticos y de almacenamiento que puede usar para
ejecutar y almacenar funciones. Los siguientes límites se aplican por región y pueden aumentarse. Para
solicitar un aumento, utilice la consola del Centro de soporte.

Recurso Límite predeterminado

Ejecuciones simultáneas 1,000

Almacenamiento de funciones y capas 75 GB

Interfaces de red elástica por VPC (p. 78) 250

Para más información sobre simultaneidad y cómo Lambda amplía la simultaneidad de funciones en
respuesta al tráfico, consulte Escalado de funciones de AWS Lambda (p. 102).

Los siguientes límites se aplican a la configuración, implementación y ejecución de función. No es posible

cambiarlos.

Recurso Límite

Asignación de memoria de función (p. 52) Desde 128 MB hasta 3,008 MB, en
incrementos de 64 MB.

Tiempo de espera de la función (p. 52) 900 segundos (15 minutos)

Función variables de entorno (p. 54) 4 KB

Política basada en recursos (p. 36) de la función 20 KB

Capas de funciones (p. 74) 5 capas

Ráfaga de simultaneidad (p. 102) de la función 500 - 3000 (varía según la

región (p. 102))

Frecuencia de invocación (solicitudes por segundo) Límite de ejecuciones simultáneas

10 veces mayor (síncrona (p. 88):
todos los orígenes)

Límite de ejecuciones simultáneas

10 veces mayor (asíncrona (p. 89):
orígenes que no pertenecen a AWS)

Sin límite (asíncrona: orígenes de

servicios de AWS (p. 153))

30
 AWS Lambda Guía para desarrolladores
Límites

Recurso Límite

Carga de invocación (p. 87) (solicitud y respuesta) 6 MB (sincrónica)

256 KB (asincrónica)

Tamaño del paquete de implementación (p. 21) 50 MB (comprimido, para cargas

directas)

250 MB (descomprimido, incluidas las

capas)

3 MB (editor de consola)

Eventos de prueba (editor de consola) 10

/tmp almacenamiento del directorio 512 MB

Descriptores de archivo 1,024

Ejecución procesos/subprocesos 1,024

Los límites para otros servicios, como AWS Identity and Access Management, Amazon CloudFront
(Lambda@Edge) y Amazon Virtual Private Cloud, pueden repercutir en sus funciones Lambda. Para
obtener más información, consulte Límites de los servicios de AWS y Uso de AWS Lambda con otros
servicios (p. 153).

31
 AWS Lambda Guía para desarrolladores
Rol de ejecución

Permisos de AWS Lambda

Puede utilizar AWS Identity and Access Management (IAM) para administrar el acceso a la API de Lambda
y a recursos como las funciones y las capas. Para los usuarios y las aplicaciones de la cuenta que utilizan
Lambda, puede administrar los permisos en una política de permisos que puede aplicar a los usuarios,
grupos o roles de IAM. Para conceder permisos a otras cuentas o servicios de AWS que utilizan recursos
de Lambda, se utiliza una política que se aplica al propio recurso.

Una función de Lambda también tiene una política, que se denomina rol de ejecución (p. 32), que la
concede permiso para tener acceso a los servicios y recursos de AWS. Como mínimo, la función necesita
tener acceso a Amazon CloudWatch Logs para el streaming de registros. Si utiliza AWS X-Ray para
rastrear la función (p. 404), o la función tiene acceso a los servicios con el SDK de AWS, debe conceder
permiso a la función para llamarlos mediante el rol de ejecución. Lambda también utiliza el rol de ejecución
para obtener permiso para leer desde orígenes de eventos cuando se utiliza un mapeo de origen de
eventos (p. 97) para activar la función.
Note
Si la función necesita acceso de red a un recurso como una base de datos relacional a la que no
se tiene acceso a través de las API de AWS o de Internet, configúrela para que se conecte a la
VPC (p. 78).

Utilice las políticas basadas en recursos (p. 36) para conceder a otras cuentas y otros servicios de AWS
permiso para utilizar los recursos de Lambda. Los recursos de Lambda incluyen funciones, versiones, alias
y versiones de las capas. Cada uno de estos recursos tiene una política de permisos que se aplica cuando
se obtiene acceso al recurso, además de las políticas que se aplican al usuario. Cuando un servicio de
AWS como Amazon S3 llama a una función de Lambda, la política basada en recursos le concede acceso.

Para administrar los permisos de los usuarios y las aplicaciones en sus cuentas, utilice las políticas
administradas que proporciona Lambda (p. 41) o cree las suyas propias. La consola de Lambda utiliza
múltiples servicios para obtener información sobre la configuración y los desencadenadores de la función.
Puede utilizar las políticas administradas tal como están, o como punto de partida para políticas más
restrictivas.

Puede restringir los permisos de usuario por el recurso al que afecta una acción y, en algunos casos,
por condiciones adicionales. Por ejemplo, puede especificar un patrón para el nombre de recurso
de Amazon (ARN) de una función que requiera que el usuario incluya su nombre de usuario en el
nombre de las funciones que cree. Además, puede añadir una condición que requiera que el usuario
configure las funciones para que utilicen una capa específica, por ejemplo, para incluir software de
registro. Para conocer los recursos y las condiciones compatibles con cada acción, consulte Recursos y
condiciones (p. 45).

Para obtener más información acerca de IAM, consulte ¿Qué es IAM? en la Guía del usuario de IAM.

Temas
• Rol de ejecución de AWS Lambda (p. 32)
• Uso de políticas basadas en recursos para AWS Lambda (p. 36)
• Políticas basadas en identidad de IAM para AWS Lambda (p. 41)
• Recursos y condiciones para acciones de Lambda (p. 45)
• Uso de límites de permisos para aplicaciones de AWS Lambda (p. 49)

Rol de ejecución de AWS Lambda

El rol de ejecución de una función de AWS Lambda concede permiso a la función para que tenga acceso
a los servicios y recursos de AWS. Debe proporcionar este rol al crear una función, y Lambda asume el rol

32
 AWS Lambda Guía para desarrolladores
Rol de ejecución

cuando se invoca la función. Puede crear un rol de ejecución para tareas de desarrollo que tenga permiso
para enviar registros a Amazon CloudWatch y para cargar datos de rastreo en AWS X-Ray.

Para ver el rol de ejecución de una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Elija Permissions.
4. El resumen de recursos muestra los servicios y recursos a los que tiene acceso la función. En el
ejemplo siguiente se muestran los permisos de CloudWatch Logs que se Lambda añade a una función
de ejecución cuando la crea en la consola de Lambda.

5. Elija un servicio en el menú desplegable para ver los permisos relacionados con ese servicio.

Puede añadir o eliminar permisos del rol de ejecución de una función en cualquier momento, o configurar
la función para que utilice otro rol. Añada permisos para los servicios a los que llame la función con el SDK
de AWS y para los servicios que Lambda utilice para habilitar características opcionales.

Cuando añade permisos a su función, actualice también su código o configuración. Esto obliga a las
instancias en ejecución de su función, cuyas credenciales han expirado, a detenerse y ser sustituidas.

33
 AWS Lambda Guía para desarrolladores
Creación de un rol de ejecución en la consola de IAM

Creación de un rol de ejecución en la consola de IAM

De forma predeterminada, Lambda crea un rol de ejecución con permisos mínimos al crear una
función (p. 3) en la consola de Lambda. También puede crear un rol de ejecución en la consola de IAM.

Para crear un rol de ejecución en la consola de IAM

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. En Common use cases (Casos de uso comunes), elija Lambda.
4. Elija Next: Permissions.
5. En Attach permissions policies (Asociar políticas de permisos), elija las políticas administradas
AWSLambdaBasicExecutionRole y AWSXRayDaemonWriteAccess.
6. Elija Next: Tags (Siguiente: Etiquetas).
7. Elija Next: Review.
8. En Role name (Nombre del rol), escriba lambda-role.
9. Elija Create role (crear rol).

Para obtener instrucciones detalladas, consulte Creación de un rol en la Guía del usuario de IAM.

Administración de roles con la API de IAM

Una función de ejecución es una función de IAM que Lambda puede asumir cuando se invoca una función.
Para crear un rol de ejecución con la CLI de AWS, utilice el comando create-role.

$ aws iam create-role --role-name lambda-ex --assume-role-policy-document [Link]

[Link]
{
"Role": {
"Path": "/",
"RoleName": "lambda-ex",
"RoleId": "AROAQFOXMPL6TZ6ITKWND",
"Arn": "arn:aws:iam::123456789012:role/lambda-ex",
"CreateDate": "2020-01-17T23:19:12Z",
"AssumeRolePolicyDocument": {
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "sts:AssumeRole"
}
]
}
}
}

El archivo [Link] es un archivo JSON en el directorio actual que define la política de

confianza del rol. Esta política de confianza permite a Lambda utilizar los permisos del rol dando al servicio
principal [Link] permiso para llamar a la acción AssumeRole de AWS Security Token
Service.

34
 AWS Lambda Guía para desarrolladores
Políticas administradas para características de Lambda

Example [Link]

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "sts:AssumeRole"
}
]
}

También puede especificar la política de confianza insertada. Los requisitos de las cuotas de escape en la
cadena JSON varía según el shell.

$ aws iam create-role --role-name lambda-ex --assume-role-policy-document

'{"Version": "2012-10-17","Statement": [{ "Effect": "Allow", "Principal": {"Service":
"[Link]"}, "Action": "sts:AssumeRole"}]}'

Para añadir permisos al rol, use el comando attach-policy-to-role. Empiece añadiendo la política
administrada AWSLambdaBasicExecutionRole.

$ aws iam attach-role-policy --role-name lambda-ex --policy-arn arn:aws:iam::aws:policy/

service-role/AWSLambdaBasicExecutionRole

Políticas administradas para características de

Lambda
Las siguientes políticas administradas proporcionan los permisos necesarios para utilizar las
características de Lambda:

• AWSLambdaBasicExecutionRole: permiso para cargar registros en CloudWatch.

• AWSLambdaKinesisExecutionRole: permiso para leer eventos de un consumidor o de un flujo de datos
de Amazon Kinesis.
• AWSLambdaDynamoDBExecutionRole: permiso para leer registros de un flujo de Amazon DynamoDB.
• AWSLambdaSQSQueueExecutionRole: permiso para leer un mensaje de una cola de Amazon Simple
Queue Service (Amazon SQS).
• AWSLambdaVPCAccessExecutionRole: permiso para administrar interfaces de red elásticas para
conectar la función a una VPC.
• AWSXRayDaemonWriteAccess: permiso para cargar los datos de seguimiento en –.

Para algunas características, la consola de Lambda intenta agregar permisos que faltan a su rol de
ejecución en una política administrada por el cliente. Estas políticas pueden llegar a ser numerosas. Añada
las políticas administradas pertinentes a su rol de ejecución antes de habilitar las funciones para evitar
crear políticas adicionales.

Cuando se utiliza un mapeo de origen de eventos (p. 97) para invocar la función, Lambda utiliza el rol
de ejecución para leer los datos de los eventos. Por ejemplo, un mapeo de origen de eventos para Amazon
Kinesis lee los eventos de un flujo de datos y se los envía a la función por lotes. Es posible utilizar los
mapeos de orígenes de eventos con los siguientes servicios:

35
 AWS Lambda Guía para desarrolladores
Políticas basadas en recursos

Servicios cuyos eventos lee Lambda

• Amazon Kinesis (p. 233)

• Amazon DynamoDB (p. 204)
• Amazon Simple Queue Service (p. 277)

Además de las políticas administradas, la consola de Lambda proporciona plantillas para crear una política
personalizada que tiene los permisos relacionados con otros casos de uso. Cuando crea una función en
la consola de Lambda, puede elegir crear un nuevo rol de ejecución con permisos a partir de una o más
plantillas. Estas plantillas también se aplican automáticamente cuando se crea una función a partir de un
proyecto o cuando se configuran opciones que requieren acceso a otros servicios. Existen plantillas de
ejemplo en el repositorio de GitHub de esta guía.

Uso de políticas basadas en recursos para AWS

Lambda
AWS Lambda admite políticas de permisos basadas en recursos para las funciones y las capas de
Lambda. Las políticas basadas en recursos le permiten conceder a otras cuentas permisos de uso para
cada recurso. También puede utilizar una política basada en recursos para permitir que un servicio de
AWS invoque una función.

Para las funciones de Lambda, puede conceder a una cuenta permiso (p. 38) para invocar o administrar
una función. Puede añadir varias instrucciones para conceder acceso a varias cuentas, o permitir que
cualquier cuenta invoque la función. Para las funciones que otro servicio de AWS invoca como respuesta a
la actividad de su cuenta, utilice la política para conceder permiso de invocación al servicio (p. 38).

Para ver la política basada en recursos de una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Elija Permissions.
4. La política basada en recursos muestra los permisos que se aplican cuando otra cuenta o servicio de
AWS intenta acceder a la función. En el ejemplo siguiente se muestra una instrucción que permite a
Amazon S3 invocar una función denominada my-function para un bucket denominado my-bucket
en la cuenta 123456789012.

36
 AWS Lambda Guía para desarrolladores
Políticas basadas en recursos

Para las capas de Lambda, utilice una política basada en recursos en una versión de la capa para permitir
que otras cuentas la utilicen. Además de las políticas que conceden permisos a una única cuenta o a todas
las cuentas, para las capas, también puede conceder permisos a todas las cuentas de una organización.
Note

Solo puede actualizar directivas basadas en recursos para recursos de Lambda en el ámbito
de las acciones API AddPermission (p. 452) y AddLayerVersionPermission (p. 449). No
puede crear políticas para los recursos de Lambda en JSON ni utilizar condiciones que no se
correspondan con los parámetros de estas acciones.

Las políticas basadas en recursos se aplican a una sola función, versión, alias o versión de capa.
Conceden permiso para uno o varios servicios y cuentas. Para las cuentas de confianza que desea
que tengan acceso a varios recursos, o para utilizar las acciones de la API que las políticas basadas en
recursos no admiten, puede utilizar roles entre cuentas (p. 41).

Temas
• Concesión de acceso a las funciones a los servicios de AWS (p. 38)
• Concesión de acceso a las funciones a otras cuentas (p. 38)
• Concesión de acceso a las capas a otras cuentas (p. 40)
• Limpieza de políticas basadas en recursos (p. 40)

37
 AWS Lambda Guía para desarrolladores
Concesión de acceso a las funciones a los servicios de AWS

Concesión de acceso a las funciones a los servicios

de AWS
Cuando se utiliza un servicio de AWS para invocar una función (p. 153), se debe conceder permiso en
una instrucción de una política basada en recursos. Puede aplicar la instrucción a la función o limitarla a
una única versión o a un solo alias.
Note

Cuando se añade un desencadenador a la función con la consola de Lambda, esta actualiza la

política basada en recursos de la función para permitir al servicio que la invoque. Para conceder
permisos a otras cuentas o servicios que no están disponibles en la consola de Lambda, utilice la
CLI de AWS.

Añada una instrucción con el comando add-permission. La instrucción más sencilla de una política
basada en recursos permite un servicio invocar una función. El comando siguiente concede permiso a
Amazon SNS para invocar una función denominada my-function.

$ aws lambda add-permission --function-name my-function --action lambda:InvokeFunction --

statement-id sns \
--principal [Link] --output text
{"Sid":"sns","Effect":"Allow","Principal":
{"Service":"[Link]"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us-
east-2:123456789012:function:my-function"}

Esto permite a Amazon SNS invocar la función, pero no restringe el tema de Amazon SNS que activa la
invocación. Para asegurarse de que la función solo la invocada un recurso determinado, especifique el
nombre de recurso de Amazon (ARN) del recurso con la opción source-arn. El siguiente comando solo
permite a Amazon SNS invocar la función para las suscripciones a un tema denominado my-topic.

$ aws lambda add-permission --function-name my-function --action lambda:InvokeFunction --

statement-id sns-my-topic \
--principal [Link] --source-arn arn:aws:sns:us-east-2:123456789012:my-topic

Algunos servicios pueden invocar funciones de otras cuentas. Esto no es un problema cuando se
especifica un ARN de origen que incluye el ID de la cuenta. Sin embargo, para Amazon S3, el origen es un
bucket cuyo ARN no incluye el ID de la cuenta. Es posible que usted elimine el bucket y que otra cuenta
cree un bucket con el mismo nombre. Utilice la opción account-id para garantizar que solo los recursos
de su cuenta pueden invocar la función.

$ aws lambda add-permission --function-name my-function --action lambda:InvokeFunction --

statement-id s3-account \
--principal [Link] --source-arn arn:aws:s3:::my-bucket-123456 --source-
account 123456789012

Concesión de acceso a las funciones a otras cuentas

Para conceder permisos a otra cuenta de AWS, especifique el ID de la cuenta como principal. En el
siguiente ejemplo, se concede permiso a la cuenta 210987654321 para invocar my-function con el
alias prod.

$ aws lambda add-permission --function-name my-function:prod --statement-id xaccount --

action lambda:InvokeFunction \

38
 AWS Lambda Guía para desarrolladores
Concesión de acceso a las funciones a otras cuentas

--principal 210987654321 --output text

{"Sid":"xaccount","Effect":"Allow","Principal":
{"AWS":"arn:aws:iam::210987654321:root"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us
east-2:123456789012:function:my-function"}

La política basada en recursos concede permiso a la otra cuenta para obtener acceso a la función, pero no
permite a los usuarios de esa cuenta superar sus permisos. Los usuarios de la otra cuenta deben tener los
permisos de usuario (p. 41) correspondientes para utilizar la API de Lambda.

Para limitar el acceso a un usuario, grupo o función de otra cuenta, especifique el ARN completo de la
identidad como el principal. Por ejemplo, arn:aws:iam::123456789012:user/developer.

El alias (p. 70) limita la versión que puede invocar la otra cuenta. Requiere que la otra cuenta incluya el
alias en el ARN de la función.

$ aws lambda invoke --function-name arn:aws:lambda:us-west-2:123456789012:function:my-

function:prod out
{
"StatusCode": 200,
"ExecutedVersion": "1"
}

Esto le permite actualizar el alias para que apunte a las versiones nuevas cuando sea necesario. Cuando
actualice el alias, la otra cuenta no tiene que modificar su código para utilizar la versión nueva, y solo tiene
permiso para invocar la versión que usted elija.

Puede conceder acceso entre cuentas para la mayoría de acciones de la API que operen con una función
existente (p. 47). Por ejemplo, puede conceder acceso a lambda:ListAliases para permitir que una
cuenta obtenga una lista de alias o a lambda:GetFunction para permitirles que descarguen el código
de la función. Añada cada permiso por separado o utilice lambda:* para conceder acceso a todas las
acciones para la función especificada.

API entre cuentas

• Invoke (p. 527)

• GetFunction (p. 500)
• GetFunctionConfiguration (p. 505)
• UpdateFunctionCode (p. 598)
• DeleteFunction (p. 481)
• PublishVersion (p. 563)
• ListVersionsByFunction (p. 556)
• CreateAlias (p. 456)
• GetAlias (p. 493)
• ListAliases (p. 534)
• UpdateAlias (p. 588)
• DeleteAlias (p. 475)
• GetPolicy (p. 522)
• PutFunctionConcurrency (p. 570)
• DeleteFunctionConcurrency (p. 483)
• ListTags (p. 554)
• TagResource (p. 584)

39
 AWS Lambda Guía para desarrolladores
Concesión de acceso a las capas a otras cuentas

• UntagResource (p. 586)

Para conceder a otras cuentas permiso para varias funciones o para realizar acciones que no operan con
una función, utilice los roles (p. 41).

Concesión de acceso a las capas a otras cuentas

Para conceder el permiso de uso de capa a otra cuenta, añada una instrucción a la política de permisos de
la versión de la capa con el comando add-layer-version-permission. En cada instrucción, puede
conceder permiso a una única cuenta, a todas las cuentas o a una organización.

$ aws lambda add-layer-version-permission --layer-name xray-sdk-nodejs --statement-id

xaccount \
--action lambda:GetLayerVersion --principal 210987654321 --version-number 1 --output text
e210ffdc-e901-43b0-824b-5fcd0dd26d16 {"Sid":"xaccount","Effect":"Allow","Principal":
{"AWS":"arn:aws:iam::210987654321:root"},"Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:u
east-2:123456789012:layer:xray-sdk-nodejs:1"}

Los permisos solo se aplican a una única versión de una capa. Repita el procedimiento cada vez que cree
una nueva versión de la capa.

Para conceder permiso a todas las cuentas de una organización, utilice la opción organization-id. En
el siguiente ejemplo, se concede permiso a todas las cuentas de una organización para utilizar la versión 3
de una capa.

$ aws lambda add-layer-version-permission --layer-name my-layer \

--statement-id engineering-org --version-number 3 --principal '*' \
--action lambda:GetLayerVersion --organization-id o-t194hfs8cz --output text
b0cd9796-d4eb-4564-939f-de7fe0b42236 {"Sid":"engineering-
org","Effect":"Allow","Principal":"*","Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-
east-2:123456789012:layer:my-layer:3","Condition":{"StringEquals":{"aws:PrincipalOrgID":"o-
t194hfs8cz"}}}"

Para conceder permiso a todas las cuentas de AWS, utilice * para la entidad principal y omita el ID de la
organización. Para varias cuentas u organizaciones, agregue varias instrucciones.

Limpieza de políticas basadas en recursos

Para ver la política basada en recursos de una función, utilice el comando get-policy.

$ aws lambda get-policy --function-name my-function --output text

{"Version":"2012-10-17","Id":"default","Statement":
[{"Sid":"sns","Effect":"Allow","Principal":
{"Service":"[Link]"},"Action":"lambda:InvokeFunction","Resource":"arn:aws:lambda:us-
east-2:123456789012:function:my-function","Condition":{"ArnLike":
{"AWS:SourceArn":"arn:aws:sns:us-east-2:123456789012:lambda*"}}}]} 7c681fc9-b791-4e91-
acdf-eb847fdaa0f0

Para las versiones y los alias, añada el número de versión o el alias al nombre de la función.

$ aws lambda get-policy --function-name my-function:PROD

Para eliminar permisos de una función, utilice remove-permission.

$ aws lambda remove-permission --function-name example --statement-id sns

40
 AWS Lambda Guía para desarrolladores
Políticas de usuario

Utilice el comando get-layer-version-policy para ver los permisos de una capa. Se utiliza remove-
layer-version-permission para quitar instrucciones de la política.

$ aws lambda get-layer-version-policy --layer-name my-layer --version-number 3 --output

text
b0cd9796-d4eb-4564-939f-de7fe0b42236 {"Sid":"engineering-
org","Effect":"Allow","Principal":"*","Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:us-
west-2:123456789012:layer:my-layer:3","Condition":{"StringEquals":{"aws:PrincipalOrgID":"o-
t194hfs8cz"}}}"

$ aws lambda remove-layer-version-permission --layer-name my-layer --version-number 3 --

statement-id engineering-org

Políticas basadas en identidad de IAM para AWS

Lambda
Puede utilizar las políticas basadas en identidad de AWS Identity and Access Management (IAM) para
conceder a los usuarios de su cuenta acceso a Lambda. Las políticas basadas en identidad se pueden
aplicar a los usuarios directamente, o a los grupos y roles que están asociados a un usuario. También
puede conceder a los usuarios de otra cuenta permiso para asumir un rol de su cuenta y tener acceso a
sus recursos de Lambda.

Lambda proporciona políticas administradas que conceden acceso a las acciones de la API de Lambda y,
en algunos casos, a otros servicios que se utilizan para desarrollar y administrar los recursos de Lambda.
Lambda actualiza las políticas administradas según sea necesario para garantizar que los usuarios tengan
acceso a las características nuevas que se publiquen.

• AWSLambdaFullAccess: concede acceso completo a las acciones de AWS Lambda y a otros servicios
que se utilizan para desarrollar y mantener los recursos de Lambda.
• AWSLambdaReadOnlyAccess: concede acceso de solo lectura a los recursos de AWS Lambda.
• AWSLambdaRole: concede permisos para invocar funciones de Lambda.

Las políticas administradas conceden permiso a las acciones de la API sin restringir las funciones ni las
capas que un usuario puede modificar. Para conseguir un control más preciso, puede crear sus propias
políticas que limiten el ámbito de los permisos de un usuario.

Secciones
• Desarrollo de funciones (p. 41)
• Desarrollo y uso de capas (p. 44)
• Roles entre cuentas (p. 45)

Desarrollo de funciones
A continuación, se muestra un ejemplo de una política de permisos con un ámbito limitado. Permite a un
usuario crear y administrar funciones de Lambda cuyo nombre tiene un prefijo determinado (intern-) y
que están configuradas con un rol de ejecución determinado.

Example Política para el desarrollo de funciones

{
"Version": "2012-10-17",

41
 AWS Lambda Guía para desarrolladores
Desarrollo de funciones

"Statement": [
{
"Sid": "ReadOnlyPermissions",
"Effect": "Allow",
"Action": [
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListTags",
"lambda:GetEventSourceMapping",
"lambda:ListEventSourceMappings",
"iam:ListRoles"
],
"Resource": "*"
},
{
"Sid": "DevelopFunctions",
"Effect": "Allow",
"NotAction": [
"lambda:AddPermission",
"lambda:PutFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:*:function:intern-*"
},
{
"Sid": "DevelopEventSourceMappings",
"Effect": "Allow",
"Action": [
"lambda:DeleteEventSourceMapping",
"lambda:UpdateEventSourceMapping",
"lambda:CreateEventSourceMapping"
],
"Resource": "*",
"Condition": {
"StringLike": {
"lambda:FunctionArn": "arn:aws:lambda:*:*:function:intern-*"
}
}
},
{
"Sid": "PassExecutionRole",
"Effect": "Allow",
"Action": [
"iam:ListRolePolicies",
"iam:ListAttachedRolePolicies",
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::*:role/intern-lambda-execution-role"
},
{
"Sid": "ViewExecutionRolePolicies",
"Effect": "Allow",
"Action": [
"iam:GetPolicy",
"iam:GetPolicyVersion"
],
"Resource": "arn:aws:iam::aws:policy/*"
},
{
"Sid": "ViewLogs",
"Effect": "Allow",
"Action": [
"logs:*"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/intern-*"
}

42
 AWS Lambda Guía para desarrolladores
Desarrollo de funciones

]
}

Los permisos de la política están organizados en instrucciones que se basan en las condiciones y los
recursos (p. 45) a los que se aplican.

• ReadOnlyPermissions: la consola de Lambda utiliza estos permisos cuando se buscan y se

visualizan las funciones. No admiten patrones de recursos ni condiciones.

"Action": [
"lambda:GetAccountSettings",
"lambda:ListFunctions",
"lambda:ListTags",
"lambda:GetEventSourceMapping",
"lambda:ListEventSourceMappings",
"iam:ListRoles"
],
"Resource": "*"

• DevelopFunctions: permite utilizar cualquier acción de Lambda que opera sobre las funciones
cuyo nombre tiene el prefijo intern-, excepto AddPermission y PutFunctionConcurrency.
AddPermission modifica la política basada en recursos (p. 36) de la función y puede afectar a
la seguridad. PutFunctionConcurrency reserva capacidad de escalado para una función y puede
restar capacidad a las otras funciones.

"NotAction": [
"lambda:AddPermission",
"lambda:PutFunctionConcurrency"
],
"Resource": "arn:aws:lambda:*:*:function:intern-*"

• DevelopEventSourceMappings: permite administrar los mapeos de orígenes de eventos en

funciones cuyo nombre tiene el prefijo intern-. Estas acciones operan sobre los mapeos de orígenes
de eventos, pero es posible restringirlas para las distintas funciones utilizando una condición.

"Action": [
"lambda:DeleteEventSourceMapping",
"lambda:UpdateEventSourceMapping",
"lambda:CreateEventSourceMapping"
],
"Resource": "*",
"Condition": {
"StringLike": {
"lambda:FunctionArn": "arn:aws:lambda:*:*:function:intern-*"
}
}

• PassExecutionRole: permite ver y pasar únicamente un rol denominado intern-lambda-

execution-role, que debe crear y administrar un usuario con permisos de IAM. PassRole se utiliza
cuando se asigna un rol de ejecución a una función.

"Action": [
"iam:ListRolePolicies",
"iam:ListAttachedRolePolicies",
"iam:GetRole",
"iam:PassRole"
],

43
 AWS Lambda Guía para desarrolladores
Desarrollo y uso de capas

"Resource": "arn:aws:iam::*:role/intern-lambda-execution-role"

• ViewExecutionRolePolicies: permite ver las políticas administradas proporcionada por AWS que
están asociadas al rol de ejecución. Esto le permite ver los permisos de la función en la consola, pero no
incluye permiso para ver las políticas creadas por otros usuarios de la cuenta.

"Action": [
"iam:GetPolicy",
"iam:GetPolicyVersion"
],
"Resource": "arn:aws:iam::aws:policy/*"

• ViewLogs: permite utilizar CloudWatch Logs para ver los registros de las funciones cuyo nombre tiene
el prefijo intern-.

"Action": [
"logs:*"
],
"Resource": "arn:aws:logs:*:*:log-group:/aws/lambda/intern-*"

Esta política permite a un usuario comenzar a utilizar Lambda sin poner en peligro los recursos de los
demás usuarios. No permite a un usuario configurar una función que llame a otros servicios de AWS o
que se active desde ellos. Esto requiere permisos de IAM más amplios. Tampoco incluye permiso para
los servicios que no admiten políticas de ámbito limitado, como CloudWatch y X-Ray. Utilice las políticas
de solo lectura para estos servicios con objeto de dar a los usuarios acceso a las métricas y los datos de
rastreo.

Al configurar desencadenadores para una función, necesita acceso para utilizar el servicio de AWS que
invoca la función. Por ejemplo, para configurar un desencadenador de Amazon S3, necesita permiso para
las acciones de Amazon S3 que permiten administrar notificaciones de buckets. Muchos de estos permisos
están incluidos en la política administrada AWSLambdaFullAccess. Existen políticas de ejemplo en el
repositorio de GitHub de esta guía.

Desarrollo y uso de capas

La siguiente política concede a un usuario permiso para crear capas y usarlas con las funciones. Los
patrones de recursos permiten al usuario trabajar en cualquier región de AWS y con cualquier versión de
las capas, siempre y cuando el nombre de la capa comience por test-.

Example Política de desarrollo de capas

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PublishLayers",
"Effect": "Allow",
"Action": [
"lambda:PublishLayerVersion"
],
"Resource": "arn:aws:lambda:*:*:layer:test-*"
},
{
"Sid": "ManageLayerVersions",
"Effect": "Allow",
"Action": [
"lambda:GetLayerVersion",

44
 AWS Lambda Guía para desarrolladores
Roles entre cuentas

"lambda:DeleteLayerVersion"
],
"Resource": "arn:aws:lambda:*:*:layer:test-*:*"
}
]
}

También puede hacer obligatorio el uso de capas durante la creación y configuración de funciones con
la condición lambda:Layer. Por ejemplo, puede impedir que los usuarios utilicen capas publicados
por otras cuentas. La siguiente política añade una condición a las acciones CreateFunction y
UpdateFunctionConfiguration para exigir que las capas especificadas procedan de la cuenta
123456789012.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ConfigureFunctions",
"Effect": "Allow",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Resource": "*",
"Condition": {
"ForAllValues:StringLike": {
"lambda:Layer": [
"arn:aws:lambda:*:123456789012:layer:*:*"
]
}
}
}
]
}

Para asegurarse de que se aplica la condición, compruebe que ninguna otra instrucción conceda al usuario
permiso para estas acciones.

Roles entre cuentas

Puede aplicar cualquiera de las instrucciones y políticas anteriores a un rol que, a continuación, puede
compartir con otra cuenta para que esta tenga acceso a sus recursos de Lambda. A diferencia de un
usuario de IAM, un rol no tiene credenciales para la autenticación. En lugar de ello, tiene una política de
confianza que especifica quién puede asumir el rol y utilizar sus permisos.

Puede utilizar roles entre cuentas para conceder acceso a las acciones y los recursos de Lambda a las
cuentas en las que confía. Si solo desea conceder permiso para invocar una función o utilizar una capa,
utilice las políticas basadas en recursos (p. 36) en su lugar.

Para obtener más información, consulte Roles de IAM en la Guía del usuario de IAM.

Recursos y condiciones para acciones de Lambda

Puede restringir el ámbito de los permisos de un usuario mediante la especificación de recursos y
condiciones en una política de IAM. Todas las acciones de API admiten una combinación de tipos de
condición y recursos que varía en función del comportamiento de la acción.

Cada instrucción de una política de IAM concede permiso para realizar una acción en un recurso. Cuando
la acción no actúa sobre un recurso designado, o cuando se concede permiso para realizar la acción

45
 AWS Lambda Guía para desarrolladores
Recursos y condiciones

en todos los recursos, el valor del recurso en la política es un comodín (*). Para muchas acciones de
API, puede restringir los recursos que un usuario puede modificar si especifica el nombre de recurso de
Amazon (ARN) de un recurso o un patrón de ARN que coincida con varios recursos.

Para restringir los permisos por recurso, especifique el recurso por ARN.

Formato de ARN de los recursos de Lambda

• Función: arn:aws:lambda:us-west-2:123456789012:function:my-function
• Versión de la función: – arn:aws:lambda:us-west-2:123456789012:function:my-function:1
• Alias de función: arn:aws:lambda:us-west-2:123456789012:function:my-function:TEST
• Mapeo de origen de eventos: arn:aws:lambda:us-west-2:123456789012:event-source-
mapping:fa123456-14a1-4fd2-9fec-83de64ad683de6d47
• Capa: arn:aws:lambda:us-west-2:123456789012:layer:my-layer
• Versión de la capa: arn:aws:lambda:us-west-2:123456789012:layer:my-layer:1

Por ejemplo, la siguiente política permite que un usuario de la cuenta 123456789012 invoque una función
denominada my-function en la región [Link]. Oeste (Oregón).

Example Invocación de una política de función

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Invoke",
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:my-function"
}
]
}

Se trata de un caso especial donde el identificador de la acción (lambda:InvokeFunction) difiere de la

operación de la API (Invoke (p. 527)). Para otras acciones, el identificador de la acción es el nombre de
la operación con el prefijo lambda:.

Las condiciones son un elemento opcional de la política que aplica lógica adicional para determinar si
se permite o no una acción. Además de las condiciones comunes compatibles con todas las acciones,
Lambda define tipos de condición que puede utilizar para restringir los valores de parámetros adicionales
en algunas acciones.

Por ejemplo, la condición lambda:Principal le permite restringir el servicio o la cuenta a los que
un usuario puede conceder acceso de invocación en la política basada en recursos de una función. La
siguiente política permite a un usuario conceder permiso para que los temas de SNS invoquen una función
denominada test.

Example Administración de permisos de una política de función

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ManageFunctionPolicy",
"Effect": "Allow",
"Action": [
"lambda:AddPermission",

46
 AWS Lambda Guía para desarrolladores
Funciones

"lambda:RemovePermission"
],
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:test:*",
"Condition": {
"StringEquals": {
"lambda:Principal": "[Link]"
}
}
}
]
}

La condición requiere que el principal sea Amazon SNS y no otro servicio o cuenta. El patrón de recursos
requiere que el nombre de la función sea test e incluye un número de versión o alias. Por ejemplo,
test:v1.

Para obtener más información sobre los recursos y las condiciones para Lambda y otros servicios de AWS,
consulte Claves de condición, recursos y acciones en la Guía del usuario de IAM.

Secciones
• Funciones (p. 47)
• Mapeos de origen de eventos (p. 48)
• Capas (p. 48)

Funciones
Las acciones que operan sobre una función se pueden restringir a una función específica por ARN
de función, versión o alias, tal y como se describe en la siguiente tabla. Las acciones que no admiten
restricciones de recursos solo pueden concederse para todos los recursos (*).

Funciones

Acción Recurso Condición

AddPermission (p. 452) Función lambda:Principal

RemovePermission (p. 582) Versión de función

Alias de función

Invoke (p. 527) Función Ninguno

Permiso: lambda:InvokeFunction Versión de función

Alias de función

CreateFunction (p. 466) Función lambda:Layer

UpdateFunctionConfiguration (p. 605)

CreateAlias (p. 456) Función Ninguno

DeleteAlias (p. 475)

DeleteFunction (p. 481)

DeleteFunctionConcurrency (p. 483)

GetAlias (p. 493)

47
 AWS Lambda Guía para desarrolladores
Mapeos de origen de eventos

Acción Recurso Condición

GetFunction (p. 500)

GetFunctionConfiguration (p. 505)

GetPolicy (p. 522)

ListAliases (p. 534)

ListVersionsByFunction (p. 556)

PublishVersion (p. 563)

PutFunctionConcurrency (p. 570)

UpdateAlias (p. 588)

UpdateFunctionCode (p. 598)

GetAccountSettings (p. 491) * Ninguno

ListFunctions (p. 543)

ListTags (p. 554)

TagResource (p. 584)

UntagResource (p. 586)

Mapeos de origen de eventos

Para los mapeos de origen de eventos, los permisos de eliminación y actualización se pueden restringir a
un origen de eventos específico. La condición lambda:FunctionArn le permite restringir las funciones
que un usuario puede configurar para invocar un origen de eventos.

Para estas acciones, el recurso es el mapeo de origen de eventos, por lo que Lambda proporciona una
condición que permite restringir el permiso según la función que invoca el mapeo de origen de eventos.

Mapeos de origen de eventos

Acción Recurso Condición

DeleteEventSourceMapping (p. 477) Mapeo de origen de eventos lambda:FunctionArn

UpdateEventSourceMapping (p. 592)

CreateEventSourceMapping (p. 460) * lambda:FunctionArn

GetEventSourceMapping (p. 496) * Ninguno

ListEventSourceMappings (p. 537)

Capas
Las acciones de capa permiten restringir las capas que un usuario puede administrar o utilizar con una
función. Las acciones relacionadas con el uso y los permisos de capa actúan sobre una versión de una

48
 AWS Lambda Guía para desarrolladores
Límites de permisos

capa, mientras que PublishLayerVersion actúa sobre un nombre de capa. Pueden utilizar cualquiera
de ellas con comodines para restringir las capas que un usuario puede utilizar por nombre.

Capas

Acción Recurso Condición

AddLayerVersionPermission (p. 449) Versión de la capa Ninguno

RemoveLayerVersionPermission (p. 580)

GetLayerVersion (p. 514)

GetLayerVersionPolicy (p. 520)

DeleteLayerVersion (p. 487)

PublishLayerVersion (p. 559) Capa Ninguno

ListLayers (p. 546) * Ninguno

ListLayerVersions (p. 548)

Uso de límites de permisos para aplicaciones de

AWS Lambda
Al crear una aplicación (p. 135) en la consola de AWS Lambda, Lambda aplica un límite de permisos a
los roles de IAM de la aplicación. El límite de permisos limita el ámbito de rol de ejecución (p. 32) que
crea la plantilla de la aplicación para cada una de sus funciones y cualquier rol que agregue a la plantilla.
El límite de permisos evita que los usuarios con acceso de escritura al repositorio Git de la aplicación
escalen los permisos de la aplicación más allá del alcance de sus propios recursos.

Las plantillas de aplicación de la consola de Lambda incluyen una propiedad global que aplica un límite de
permisos a todas las funciones que crean.

Globals:
Function:
PermissionsBoundary: !Sub 'arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/
${AppId}-${AWS::Region}-PermissionsBoundary'

El límite limita los permisos de los roles de las funciones. Puede agregar permisos al rol de ejecución de un
rol en la plantilla, pero ese permiso solo es efectivo si también lo permite el límite de permisos. El rol que
AWS CloudFormation adopta para implementar la aplicación exige el uso del límite de permisos. Dicho rol
solo tiene permiso para crear y transferir roles que tengan asociado el límite de permisos de la aplicación.

De forma predeterminada, el límite de permisos de una aplicación permite a las funciones realizar acciones
en los recursos de la aplicación. Por ejemplo, si la aplicación incluye una tabla de Amazon DynamoDB,
el límite permite el acceso a cualquier acción de API que se pueda restringir para operar en tablas
específicas con permisos de nivel de recurso. Solo puede usar acciones que no admitan permisos de nivel
de recursos si están específicamente permitidas en el límite. Estos incluyen las acciones de API Amazon
CloudWatch Logs y AWS X-Ray para el registro y seguimiento.

Example Límite de permisos

49
 AWS Lambda Guía para desarrolladores
Límites de permisos

"Version": "2012-10-17",
"Statement": [
{
"Action": [
"*"
],
"Resource": [
"arn:aws:lambda:us-east-2:123456789012:function:my-app-getAllItemsFunction-
*",
"arn:aws:lambda:us-east-2:123456789012:function:my-app-getByIdFunction-*",
"arn:aws:lambda:us-east-2:123456789012:function:my-app-putItemFunction-*",
"arn:aws:dynamodb:us-east-1:123456789012:table/my-app-SampleTable-*"
],
"Effect": "Allow",
"Sid": "StackResources"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogGroups",
"logs:PutLogEvents",
"xray:Put*"
],
"Resource": "*",
"Effect": "Allow",
"Sid": "StaticPermissions"
},
...
]
}

Para acceder a otros recursos o acciones de API, usted o un administrador deben ampliar el límite de
permisos para incluir esos recursos. Es posible que también necesite actualizar el rol de ejecución o el rol
de implementación de una aplicación para permitir el uso de acciones adicionales.

• Límite de permisos: amplíe el límite de permisos de la aplicación cuando añada recursos a la aplicación
o el rol de ejecución necesite acceso a más acciones. En IAM, añada recursos al límite para permitir
el uso de acciones de API que admitan permisos de nivel de recursos en el tipo de recurso. Para las
acciones que no admitan permisos de nivel de recursos, añádalas en una instrucción que no esté en el
ámbito de ningún recurso.
• Rol de ejecución: amplíe el rol de ejecución de un rol cuando necesite utilizar acciones adicionales. En la
plantilla de aplicación, añada políticas al rol de ejecución. La intersección de permisos en el límite y el rol
de ejecución se concede a la función.
• Rol de implementación: amplíe el rol de implementación de la aplicación cuando necesite permisos
adicionales para crear o configurar recursos. En IAM, añada políticas al rol de implementación de
la aplicación. El rol de implementación necesita los mismos permisos de usuario que necesita para
implementar o actualizar una aplicación en AWS CloudFormation.

Para ver un tutorial que explica cómo añadir recursos a una aplicación y ampliar sus permisos, consulte
??? (p. 135).

Para obtener más información, consulte Límites de permisos para las entidades de IAM en la Guía del
usuario de IAM.

50
 AWS Lambda Guía para desarrolladores

Administración de funciones de AWS

Lambda
Puede usar la consola o API de AWS Lambda para configurar los ajustes de las funciones de Lambda.
La configuración básica de la función (p. 52) incluye la descripción, el rol y el tiempo de ejecución, que
se especifican cuando se crea una función en la consola de Lambda. Puede ajustar más aspectos de la
configuración tras crear una función o usar la API para establecer cosas como el nombre del controlador, la
asignación de memoria y los grupos de seguridad durante la creación.

Para mantener secretos fuera del código de función, almacénelos en la configuración de la función y
léalos del entorno de ejecución durante la inicialización. Las variables de entorno (p. 54) están cifradas
en todo momento y también pueden cifrarse en el lado del cliente. Utilice las variables de entorno para
hacer su código de función portátil eliminando cadenas de conexión, contraseñas y puntos de enlace con
recursos externos.

Las versiones y alias (p. 68) son recursos secundarios que puede crear para administrar la
implementación e invocación de funciones. Publique versiones (p. 68) de su función para almacenar
su código y configuración como recurso independiente que no puede cambiarse y cree un alias (p. 70)
que dirija a una versión específica. A continuación, puede configurar sus clientes para invocar un alias de
función y actualizar el alias cuando quiera dirigir el cliente a una nueva versión, en lugar de actualizar el
cliente.

A medida que agrega bibliotecas y otras dependencias a la función, la creación y la carga de un

paquete de implementación pueden ralentizar el desarrollo. Utilice capas (p. 74) para administrar
las dependencias de su función de forma independiente y mantener un tamaño del paquete de
implementación reducido. También puede utilizar capas para compartir sus propias bibliotecas con otros
clientes y utilizar capas disponibles públicamente con sus funciones.

Si desea utilizar la función Lambda con recursos de AWS en una Amazon VPC, configúrela con grupos de
seguridad y subredes para crear una conexión de VPC (p. 78). La conexión de la función a una VPC le
permite obtener acceso a los recursos de una subred privada, como bases de datos relacionales y cachés.
También puede crear un proxy de base de datos (p. 81) para instancias de base de datos MySQL y
Aurora. Un proxy de base de datos permite que una función alcance altos niveles de simultaneidad sin
agotar las conexiones de base de datos.

Temas
• Configuración de funciones en la consola de AWS Lambda (p. 52)
• Uso de variables de entorno de AWS Lambda (p. 54)
• Administración de la simultaneidad para una función Lambda (p. 59)
• Versiones de funciones de AWS Lambda (p. 68)
• Alias de función de AWS Lambda (p. 70)
• Capas de AWS Lambda (p. 74)
• Configuración de una función Lambda para obtener acceso a los recursos en una VPC (p. 78)
• Configuración del acceso a la base de datos para una función Lambda (p. 81)
• Etiquetado de funciones de Lambda (p. 83)

51
 AWS Lambda Guía para desarrolladores
Consola de configuración

Configuración de funciones en la consola de AWS

Lambda
Puede utilizar la consola de Lambda para configurar los ajustes de funciones, agregar desencadenadores
y destinos, y actualizar y probar el código.

Para administrar una función, abra la página Funciones de la consola de Lambda y elija una función. El
diseñador de funciones está en la parte superior de la página de configuración.

El diseñador muestra información general de su función y de sus recursos anteriores y posteriores. Puede
usarlo para configurar desencadenadores, capas y destinos.

• Desencadenadores: son servicios y recursos que ha configurado para invocar su función. Elija Add
trigger (Agregar desencadenador) para crear un mapeo de origen de eventos (p. 97) de Lambda
o para configurar un desencadenador en otro servicio con el que se integre la consola de Lambda.
Para obtener más información sobre estos y otros servicios, consulte Uso de AWS Lambda con otros
servicios (p. 153).
• Capas: elija el nodo Layers (Capas) para añadir capas (p. 74) a su aplicación. Una capa es un
archivo ZIP que contiene bibliotecas, un tiempo de ejecución personalizado u otras dependencias.
• Destinos: agregue un destino a su función para enviar detalles sobre los resultados de invocación a otro
servicio. Puede enviar registros de invocación cuando su función se invoca asincrónicamente (p. 89)
o mediante un mapeo de origen de eventos (p. 97) que se lee desde un flujo.

Con el nodo de función seleccionado en el diseñador, puede modificar la siguiente configuración.

Opciones de configuración de las funciones

• Code (Código): El código y las dependencias de la función. Para los lenguajes de scripting, puede editar
el código de la función en el editor (p. 6) integrado. Para añadir bibliotecas, o para los lenguajes no
admitidos por el editor, cargue un paquete de implementación (p. 21). si el paquete de implementación
tiene un tamaño mayor que 50 MB, seleccione Upload a file from (Cargar un archivo desde) Amazon S3.

52
 AWS Lambda Guía para desarrolladores
Consola de configuración

• Runtime (Tiempo de ejecución): El tiempo de ejecución de Lambda (p. 118) que ejecuta la función.
• Handler (Controlador): El método que ejecuta el tiempo de ejecución cuando se invoca la función, como
[Link]. El primer valor es el nombre del archivo o del módulo. El segundo valor es el nombre
del método.
• Environment variables (Variables de entorno): Pares clave-valor que Lambda establece en el entorno
de ejecución. Utilice variables de entorno (p. 54) para ampliar la configuración de la función fuera del
código.
• Tags (Etiquetas): Pares clave-valor que Lambda asocia al recurso de la función. Utilice las
etiquetas (p. 83) para organizar las funciones de Lambda en grupos para generar informes de costos
y filtrarlas en la consola de Lambda.

Las etiquetas se aplican a toda la función, incluidas todas las versiones y los alias.
• Execution role (Rol de ejecución): El rol de IAM (p. 32) que AWS Lambda asume cuando ejecuta la
función.
• Description (Descripción): Una descripción de la función.
• Memory (Memoria): La cantidad de memoria disponible para la función durante la ejecución. Elija una
cantidad entre 128 MB y 3,008 MB (p. 30), en incrementos de 64 MB.

Lambda asigna potencia de CPU linealmente en proporción a la cantidad de memoria configurada. Si se

configuran 1792 MB, la función tiene el equivalente de una vCPU completa (un segundo de créditos de
vCPU por segundo).
• Timeout (Tiempo de espera): La cantidad de tiempo que Lambda permite que una función se ejecute
antes de detenerla. El valor predeterminado es de 3 segundos. El valor máximo permitido es de
900 segundos.
• Virtual private cloud (VPC) (Nube virtual privada (VPC)): Si la función necesita acceso de red a recursos
que no están disponibles a través de Internet, configúrela para que se conecte a una VPC (p. 78).
• Database proxies (Proxies de base de datos): cree un proxy de base de datos (p. 81) para las
funciones que utilizan una instancia o clúster de base de datos de Amazon RDS.
• Active tracing (Rastreo activo): Realice un muestreo de las solicitudes entrantes y rastree las solicitudes
muestreadas con AWS X-Ray (p. 404).
• Concurrency (Simultaneidad): Reserve simultaneidad para una función (p. 59) y establezca el número
máximo de ejecuciones simultáneas de dicha función. Aprovisione recursos de simultaneidad para
garantizar que la función puede escalar sin que se produzcan fluctuaciones en la latencia.

La simultaneidad reservada se aplica a toda la función, incluidas todas las versiones y los alias.
• Asynchronous invocation (Invocación asincrónica): Configure el comportamiento de administración
de errores (p. 89) para reducir el número de reintentos de Lambda o el tiempo que los eventos sin
procesar permanecerán en la cola antes de que Lambda los descarte. Configure una cola de mensajes
fallidos (p. 95) para conservar los eventos descartados.

Puede configurar las opciones de gestión de errores en una función, versión o alias.

A excepción de lo indicado en la lista anterior, solo se puede modificar la configuración de función en

la versión no publicada de una función. Cuando se publica una versión, el código y la mayoría de las
opciones de configuración se bloquean para garantizar una experiencia uniforme para los usuarios de
dicha versión. Utilice los alias (p. 70) para propagar los cambios de configuración de manera controlada.

Para configurar funciones con la API de Lambda, utilice las siguientes acciones:

• UpdateFunctionCode (p. 598): actualiza el código de la función.

• UpdateFunctionConfiguration (p. 605): actualiza la configuración específica de la versión.
• TagResource (p. 584): etiqueta una función.

53
 AWS Lambda Guía para desarrolladores
Variables de entorno

• AddPermission (p. 452): modifica la política basada en recursos (p. 36) de una función, una versión o
un alias.
• PutFunctionConcurrency (p. 570): configura la simultaneidad reservada de una función.
• PublishVersion (p. 563): crea una versión inmutable con el código y la configuración actuales.
• CreateAlias (p. 456): crea alias para las versiones de la función.
• PutFunctionEventInvokeConfig: configure la gestión de errores para la invocación asincrónica.

Por ejemplo, para actualizar la configuración de memoria de una función con la AWS CLI, utilice el
comando update-function-configuration.

$ aws lambda update-function-configuration --function-name my-function --memory-size 256

Para conocer las prácticas recomendadas de configuración de funciones, consulte Función de

configuración (p. 150).

Uso de variables de entorno de AWS Lambda

Puede usar variables de entorno para almacenar secretos de forma segura y ajustar el comportamiento
de su función sin actualizar el código. Una variable de entorno es un par de cadenas almacenadas en la
configuración específica de la versión de una función. El tiempo de ejecución de Lambda hace que las
variables de entorno estén disponibles para el código y establece variables de entorno adicionales que
contienen información sobre la función y la solicitud de invocación.

Las variables de entorno se establecen en la versión no publicada de la función especificando una clave
y un valor. Al publicar una versión, las variables de entorno se bloquean para esa versión junto con otra
configuración específica de la versión (p. 52).

Para establecer variables de entorno en la Lambda consola

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Environment variables (Variables de entorno), elija Edit (Editar).
4. Elija Add environment variable (Añadir variable de entorno).
5. Introduzca una clave y un valor.

Requisitos

• Las claves comienzan con una letra y tienen como mínimo dos caracteres.
• Las claves solo contienen letras, números y guiones bajos (_).
• Las llaves no están reservadas por Lambda (p. 56).
• El tamaño total de todas las variables de entorno no supera los 4 KB.
6. Elija Save (Guardar).

Utilice variables de entorno para pasar la configuración específica del entorno a su código. Por ejemplo,
puede tener dos funciones con el mismo código pero con configuración diferente. Una función se conecta a
una base de datos de prueba y la otra se conecta a una base de datos de producción. En esta situación, se
utilizan variables de entorno para indicar a la función el nombre de host y otros detalles de conexión para la
base de datos. También puede establecer una variable de entorno para configurar el entorno de prueba y
utilizar un registro o un seguimiento más detallados.

54
 AWS Lambda Guía para desarrolladores
Variables de entorno

Para recuperar variables de entorno en el código de función, utilice el método estándar para el lenguaje de
programación.

[Link]

let region = [Link].AWS_REGION

Python

import os
region = [Link]['AWS_REGION']

Ruby

region = ENV["AWS_REGION"]

Java

String region = [Link]("AWS_REGION");

Go

var region = [Link]("AWS_REGION")

C#

string region = [Link]("AWS_REGION");

PowerShell

$region = $env:AWS_REGION

Lambda almacena variables de entorno de forma segura cifrándolas en reposo. Puede configurar Lambda
para que utilice una clave de cifrado diferente (p. 57), cifrar valores de variables de entorno del lado
del cliente o establezca variables de entorno en una plantilla de AWS CloudFormation con AWS Secrets
Manager.

Secciones
• Variables de entorno de tiempo de ejecución (p. 56)

55
 AWS Lambda Guía para desarrolladores
Variables de entorno de tiempo de ejecución

• Proteger variables de entorno (p. 57)

• Configuración de variables de entorno con la API de Lambda (p. 58)
• Código de muestra y plantillas (p. 59)

Variables de entorno de tiempo de ejecución

Los tiempos de ejecución (p. 118) de Lambda establecen varias variables de entorno durante la
inicialización. La mayoría de las variables de entorno proporcionan información sobre la función o el tiempo
de ejecución. Las claves para estas variables de entorno están reservadas y no se pueden establecer en la
configuración de la función.

Variables de entorno reservadas

• _HANDLER: Localización del controlador configurada en la función.

• AWS_REGION: La región de AWS donde se ejecuta la función de Lambda.
• AWS_EXECUTION_ENV: El identificador de tiempo de ejecución (p. 118), precedido por AWS_Lambda_
(por ejemplo, AWS_Lambda_java8).
• AWS_LAMBDA_FUNCTION_NAME: El nombre de la función.
• AWS_LAMBDA_FUNCTION_MEMORY_SIZE: La cantidad de memoria disponible para la función en MB.
• AWS_LAMBDA_FUNCTION_VERSION: La versión de la función que se está ejecutando.
• AWS_LAMBDA_LOG_GROUP_NAME, AWS_LAMBDA_LOG_STREAM_NAME: El nombre del grupo Amazon
CloudWatch Logs y el flujo de la función.
• AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN: Las claves de acceso
obtenidas del rol de ejecución (p. 32) de la función.
• AWS_LAMBDA_RUNTIME_API: (Tiempo de ejecución personalizado (p. 121)) El host y el puerto de la
API de tiempo de ejecución (p. 124).
• LAMBDA_TASK_ROOT: La ruta al código de la función de Lambda.
• LAMBDA_RUNTIME_DIR: La ruta a las bibliotecas de tiempos de ejecución.
• TZ: La zona horaria del entorno (UTC). El entorno de ejecución utiliza NTP para sincronizar el reloj del
sistema.

Las siguientes variables de entorno adicionales no están reservadas y pueden ampliarse en la

configuración de la función.

Variables de entorno sin reserva

• LANG: La configuración regional del tiempo de ejecución (en_US.UTF-8).

• PATH: La ruta de ejecución (/usr/local/bin:/usr/bin/:/bin:/opt/bin).
• LD_LIBRARY_PATH: La ruta de acceso de la biblioteca del sistema (/lib64:/usr/
lib64:$LAMBDA_RUNTIME_DIR:$LAMBDA_RUNTIME_DIR/lib:$LAMBDA_TASK_ROOT:
$LAMBDA_TASK_ROOT/lib:/opt/lib).
• NODE_PATH: ([Link] (p. 289)) La ruta de la biblioteca [Link] (/opt/nodejs/node12/
node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules).
• PYTHONPATH: (Python 2.7, 3.6, 3.8 (p. 302)) La ruta de la biblioteca de Python
($LAMBDA_RUNTIME_DIR).
• GEM_PATH: (Ruby (p. 317)) La ruta de la biblioteca Ruby ($LAMBDA_TASK_ROOT/vendor/bundle/
ruby/2.5.0:/opt/ruby/gems/2.5.0).

Los valores de muestra presentados reflejan los últimos tiempos de ejecución. La presencia de variables
específicas o sus valores pueden variar en tiempos de ejecución anteriores.

56
 AWS Lambda Guía para desarrolladores
Proteger variables de entorno

Proteger variables de entorno

Lambda cifra las variables de entorno con una clave que crea en su cuenta (una clave maestra de cliente
(CMK) administrada por AWS). El uso de esta clave es gratuito. También puede optar por proporcionar su
propia clave para Lambda y usarla en lugar de la clave predeterminada.

Cuando proporciona la clave, sólo los usuarios de su cuenta con acceso a la clave pueden ver o
administrar variables de entorno en la función. Su organización también podría tener requisitos internos o
externos para administrar las claves que son utilizadas para el cifrado y el control cuando se rotan.

Utilice una CMK administrada por el cliente.

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Environment variables (Variables de entorno), elija Edit (Editar).
4. Expanda Encryption configuration (Configuración de cifrado).
5. Seleccione Use a customer master key (Usar una clave maestra de cliente).
6. Elija su CMK administrada por el cliente.
7. Elija Save (Guardar).

Las CMK gestionadas por el cliente incurren en cargos de AWS KMSestándar.

No se requieren permisos de AWS KMS para el usuario o el rol de ejecución de la función para utilizar la
clave de cifrado predeterminada. Para utilizar una CMK administrada por el cliente, necesita permisos de
uso de la llave. Lambda usa sus permisos para crear una concesión en la clave. Esto permite a Lambda
usarlo para el cifrado.

• kms:ListAliases: Para ver las teclas en la consola de Lambda.

• kms:CreateGrant, kms:Encrypt: Para configurar un CMK administrado por el cliente en una función.
• kms:Decrypt: Para ver y administrar variables de entorno cifradas con un CMK administrado por el
cliente.

Puede obtener estos permisos a partir de su cuenta de usuario o a partir de la política de permisos
basada en recursos de una clave. La ListAliases es proporcionada por las políticas administradas en
Lambda (p. 41). Las políticas clave conceden los permisos restantes a los usuarios del grupo Usuarios
clave .

Los usuarios sin permisos Decrypt todavía pueden administrar funciones, pero no pueden ver variables
de entorno ni administrarlas en la consola de Lambda. Para evitar que un usuario vea variables de entorno,
añada una instrucción a los permisos del usuario que deniegue el acceso a la clave predeterminada, a una
clave administrada por el cliente o a todas las claves.

Example Política de IAM: Denegar Acceso por ARN de clave

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Deny",
"Action": [
"kms:Decrypt"
],
"Resource": "arn:aws:kms:us-east-2:123456789012:key/3be10e2d-xmpl-4be4-
bc9d-0405a71945cc"

57
 AWS Lambda Guía para desarrolladores
Configuración de variables de
entorno con la API de Lambda

}
]
}

Para obtener más información sobre la administración de permisos de clave, consulte Usar políticas de
clave en KMS de AWS.

También puede cifrar los valores de variables de entorno del lado del cliente antes de enviarlos a Lambda
y descifrarlos en el código de función. Esto oscurece los valores secretos de la consola de Lambda y
los resultados de la API, incluso para los usuarios que tienen permiso para usar la clave. En el código,
recuperará el valor cifrado del entorno y lo descifrará mediante la API de AWS KMS.

Para cifrar variables de entorno en el lado del cliente

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Environment variables (Variables de entorno), elija Edit (Editar).
4. Expanda Encryption configuration (Configuración de cifrado).
5. Seleccione Enable helpers for encryption in transit (Habilitar ayudantes para el cifrado en tránsito).
6. Seleccione Encrypt (Cifrar) junto a una variable para cifrar su valor.
7. Seleccione Save.

Para ver el código de ejemplo para el idioma de su función, seleccione Code (Código) junto a una variable
de entorno. El código de ejemplo muestra cómo recuperar una variable de entorno en una función y
descifrar su valor.

Otra opción es almacenar contraseñas en secretos AWS Secrets Manager. Puede hacer referencia al
secreto en sus plantillas de AWS CloudFormation para establecer contraseñas en las bases de datos.
También puede establecer el valor de una variable de entorno en la función de Lambda. Consulte la
siguiente sección para ver un ejemplo.

Configuración de variables de entorno con la API de

Lambda
Para administrar variables de entorno con la AWS CLI o el SDK de AWS, utilice las siguientes operaciones
de la API.

• UpdateFunctionConfiguration (p. 605)

• GetFunctionConfiguration (p. 505)
• CreateFunction (p. 466)

En el ejemplo siguiente se establecen dos variables de entorno en una función denominada my-
function.

58
 AWS Lambda Guía para desarrolladores
Código de muestra y plantillas

$ aws lambda update-function-configuration --function-name my-function \

--environment "Variables={BUCKET=my-bucket,KEY=[Link]}"

Cuando se aplican variables de entorno con el comando update-function-configuration, se

remplaza todo el contenido de la Variables estructura. Para conservar las variables de entorno
existentes al agregar una nueva, incluya todos los valores existentes en la solicitud.

Para obtener la configuración actual, use el comando get-function-configuration.

$ aws lambda get-function-configuration --function-name my-function

{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "my-bucket",
"KEY": "[Link]"
}
},
"RevisionId": "0894d3c1-2a3d-4d48-bf7f-abade99f3c15",
...
}

Para asegurarse de que los valores no cambian entre cuando lee la configuración y cuando la actualiza,
puede pasar el ID de revisión del resultado de get-function-configuration como parámetro a
update-function-configuration.

Para configurar la clave de cifrado de una función, establezca la opción KMSKeyARN.

$ aws lambda update-function-configuration --function-name my-function \

--kms-key-arn arn:aws:kms:us-east-2:123456789012:key/055efbb4-xmpl-4336-
ba9c-538c7d31f599

Código de muestra y plantillas

Las aplicaciones de ejemplo en el repositorio de GitHub de esta guía demuestran el uso de variables de
entorno en el código de función y en plantillas de AWS CloudFormation.

Aplicaciones de ejemplo

• En blanco: cree una función y un tema de Amazon SNS en la misma plantilla. Pase el nombre del tema a
la función en una variable de entorno. Leer variables de entorno en código (varios idiomas).
• RDS MySQL: cree una VPC y una instancia de base de datos de Amazon RDS en una plantilla, con
una contraseña almacenada en Secrets Manager. En la plantilla de aplicación, importe los detalles de la
base de datos de la pila de VPC, lea la contraseña de Secrets Manager y pase toda la configuración de
conexión a la función en variables de entorno.

Administración de la simultaneidad para una

función Lambda
La simultaneidad es el número de solicitudes que la función atiende en un momento dado. Cuando se
invoca la función, Lambda asigna una instancia para procesar el evento. Cuando el código de la función

59
 AWS Lambda Guía para desarrolladores
Configuración de la simultaneidad reservada

termina de ejecutarse, puede encargarse de otra solicitud. Si la función se invoca de nuevo mientras se
sigue procesando una solicitud, se asigna otra instancia, lo que aumenta la simultaneidad de la función.

La simultaneidad está sujeta a un límite (p. 30) regional que comparten todas las funciones de una
región. Para asegurarse de que una función pueda alcanzar siempre cierto nivel de simultaneidad,
puede configurar la función con simultaneidad reservada (p. 60). Cuando una función ha reservado
simultaneidad, ninguna otra función puede usarla. La simultaneidad reservada también limita la
simultaneidad máxima para la función y se aplica a la función como un todo, incluyendo versiones y alias.

Cuando Lambda asigna una instancia de su función, el tiempo de ejecución (p. 118) carga el código
de su función y ejecuta el código de inicialización que ha definido fuera del controlador. Si el código y las
dependencias son grandes, o si crea clientes SDK durante la inicialización, este proceso puede llevar
algún tiempo. A medida que la función aumenta (p. 102), esto provoca que la parte de las solicitudes que
atienden nuevas instancias tenga una latencia mayor que el resto.

Para que su función pueda escalar sin fluctuaciones en la latencia, utilice la simultaneidad
aprovisionada (p. 62). Mediante la asignación de la simultaneidad aprovisionada antes de un aumento
en las invocaciones, puede asegurarse de que todas las solicitudes se atiendan mediante instancias
inicializadas con una latencia muy baja. Puede configurar la simultaneidad aprovisionada en una versión
de una función o en un alias.

Lambda también se integra con Auto Scaling de aplicaciones. Puede configurar Auto Scaling de
aplicaciones para administrar la simultaneidad aprovisionada según una programación o basándose en la
utilización. Utilice el escalado programado para aumentar la simultaneidad aprovisionada para prever picos
de tráfico. Para aumentar automáticamente la concurrencia aprovisionada según se requiera, utilice la API
de Auto Scaling de aplicaciones (p. 65) para registrar un objetivo y crear una política de escalado.

La simultaneidad aprovisionada cuenta en los límites regionales y de simultaneidad reservada de una

función. Si el volumen de simultaneidad aprovisionada en las versiones y alias de una función se suma
a la simultaneidad reservada de la función, todas las invocaciones se ejecutan en la simultaneidad
aprovisionada. Esta configuración también tiene el efecto de aplicar una limitación controlada a la versión
sin publicar de la función ($LATEST), lo que impide que se ejecute.

Secciones
• Configuración de la simultaneidad reservada (p. 60)
• Configuración de simultaneidad aprovisionada (p. 62)
• Configuración de simultaneidad con la API de Lambda (p. 65)

Configuración de la simultaneidad reservada

Para administrar la configuración de la simultaneidad reservada para una función, utilice la consola de
Lambda.

Para reservar la simultaneidad para una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Concurrency (Simultaneidad), elija Reserve concurrency (Reservar simultaneidad).
4. Escriba la cantidad de simultaneidad que reservar para la función.
5. Seleccione Save (Guardar).

Puede reservar hasta el valor de Unreserved account concurrency (Simultaneidad de cuenta no reservada)
mostrado, menor a 100 para funciones que no tienen simultaneidad reservada. Para aplicar la limitación

60
 AWS Lambda Guía para desarrolladores
Configuración de la simultaneidad reservada

controlada a una función, establezca la concurrencia reservada en cero. Esto impide que los eventos se
procesen hasta que elimine el límite.

El ejemplo siguiente muestra dos funciones con grupos de simultaneidad reservada, y el grupo de
simultaneidad no reservada usado por otras funciones. Los errores de restricción ocurren cuando toda la
simultaneidad de un grupo está en uso.

Leyenda

• Simultaneidad de la función
• Simultaneidad reservada
• Simultaneidad no reservada
• Limitación.

La reserva de simultaneidad tiene los siguientes efectos.

• Otras funciones no pueden evitar que la función se escale: todas las funciones de su cuenta en la
misma región sin simultaneidad reservada comparten el grupo de simultaneidad no reservada. Sin

61
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad aprovisionada

simultaneidad reservada, otras funciones pueden utilizar toda la simultaneidad disponible. Esto impide
que la función se amplíe cuando sea necesario.
• Su función no se puede escalar fuera de control: la simultaneidad reservada también limita que la
función utilice la simultaneidad de un grupo no reservado, lo que limita su simultaneidad máxima. Puede
reservar simultaneidad para evitar que la función utilice toda la simultaneidad disponible en la región o
que sobrecargue los recursos empleados posteriormente.

La configuración de la simultaneidad por función puede afectar al grupo de simultaneidad que está
disponible para otras funciones. Para evitar problemas, limite el número de usuarios que pueden utilizar las
operaciones de la API PutFunctionConcurrency y DeleteFunctionConcurrency.

Configuración de simultaneidad aprovisionada

Para administrar la configuración de simultaneidad aprovisionada para una versión o alias, utilice la
consola de Lambda.

Para reservar la simultaneidad para una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Provisioned concurrency configurations (Configuraciones de concurrencia aprovisionadas),
seleccione Add (Agregar).
4. Elija un alias o una versión.
5. Escriba el volumen de simultaneidad aprovisionada que se asignará.
6. Seleccione Save.

Puede administrar la simultaneidad aprovisionada para todos los alias y versiones desde la página de
configuración de funciones. La lista de configuraciones de simultaneidad aprovisionadas muestra el
progreso de la asignación de cada configuración. Los ajustes de simultaneidad aprovisionada también
están disponibles en la página de configuración para cada versión y alias.

En el ejemplo siguiente, las funciones my-function-DEV y my-function-PROD se configuran tanto

con simultaneidad reservada como con simultaneidad aprovisionada. En my-function-DEV, el grupo
completo de simultaneidad reservada también es simultaneidad aprovisionada. En este caso, todas
las invocaciones o bien se ejecutan en simultaneidad aprovisionada o bien están limitadas. En my-
function-PROD, una parte del grupo de simultaneidad reservada es simultaneidad estándar. Cuando se
utiliza toda la simultaneidad aprovisionada, la función se ajusta a la simultaneidad estándar para atender
cualquier solicitud adicional.

62
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad aprovisionada

Leyenda

• Simultaneidad de la función
• Simultaneidad reservada
• Simultaneidad aprovisionada
• Simultaneidad no reservada
• Limitación.

La simultaneidad aprovisionada no se pone en línea inmediatamente después de configurarla. Lambda

comienza a asignar simultaneidad aprovisionada después de uno o dos minutos de preparación. De
manera similar a cómo las funciones se escalan bajo carga (p. 102), se pueden inicializar hasta 3000
instancias de la función a la vez, dependiendo de la Región. Después de la ráfaga inicial, las instancias
se asignan a una velocidad constante de 500 por minuto hasta que se cumple la solicitud. Cuando solicita
simultaneidad aprovisionada para varias funciones o versiones de una función en la misma Región, se
aplican límites de escala a todas las solicitudes.

63
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad aprovisionada

Leyenda

• Instancias de función
• Solicitudes abiertas
• Simultaneidad aprovisionada
• Simultaneidad estándar

El código de inicialización (p. 19) de su función se ejecuta durante la asignación y cada pocas horas, ya
que las instancias en ejecución de su función se reciclan. Puede ver el tiempo de inicialización en registros
y rastros (p. 404) después de que una instancia procese una solicitud. Sin embargo, la inicialización
se factura incluso si la instancia nunca procesa una solicitud. La simultaneidad aprovisionada se ejecuta
continuamente y se factura por separado de los costes de inicialización e invocación. Para obtener más
información, consulte Precios de AWS Lambda.

64
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad con la API de Lambda

Cada versión de una función solo puede tener una configuración de simultaneidad aprovisionada. Puede
ser directamente en la propia versión o en un alias que apunte a la versión. Dos alias no pueden asignar
simultaneidad aprovisionada para la misma versión. Tampoco puede asignar simultaneidad aprovisionada
en un alias que apunte a la versión no publicada ($LATEST).

Cuando cambia la versión a la que apunta un alias, la simultaneidad aprovisionada se desasigna

de la versión antigua y, a continuación, se asigna a la nueva. Puede añadir una configuración de
direccionamiento a un alias que tenga simultaneidad aprovisionada. Sin embargo, no puede administrar
la configuración de simultaneidad aprovisionada en el alias mientras la configuración de direccionamiento
está aplicada.

Lambda emite las siguientes métricas para la simultaneidad aprovisionada:

Métricas de simultaneidad aprovisionada

• ProvisionedConcurrentExecutions
• ProvisionedConcurrencyInvocations
• ProvisionedConcurrencySpilloverInvocations
• ProvisionedConcurrencyUtilization

Para obtener más información, consulte Trabajar con métricas de función de AWS Lambda (p. 400).

Configuración de simultaneidad con la API de Lambda

Para administrar la configuración de simultaneidad y autoescalado con la AWS CLI o el SDK de AWS,
utilice las siguientes operaciones de la API.

• PutFunctionConcurrency (p. 570)

• GetFunctionConcurrency
• DeleteFunctionConcurrency (p. 483)
• PutProvisionedConcurrencyConfig
• GetProvisionedConcurrencyConfig
• ListProvisionedConcurrencyConfigs
• DeleteProvisionedConcurrencyConfig
• GetAccountSettings (p. 491)
• (Auto Scaling de aplicaciones) RegisterScalableTarget
• (Auto Scaling de aplicaciones) PutScalingPolicy

Para configurar la simultaneidad reservada con la AWS CLI, use el comando put-function-
concurrency. El comando siguiente reserva una simultaneidad de 100 para una función llamada my-
function:

$ aws lambda put-function-concurrency --function-name my-function --reserved-concurrent-

executions 100
{
"ReservedConcurrentExecutions": 100
}

Para asignar la simultaneidad aprovisionada para una función, utilice put-provisioned-concurrency-

config. El comando siguiente asigna una simultaneidad de 100 para el alias BLUE de una función llamada
my-function:

65
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad con la API de Lambda

$ aws lambda put-provisioned-concurrency-config --function-name my-function \

--qualifier BLUE --provisioned-concurrent-executions 100
{
"Requested ProvisionedConcurrentExecutions": 100,
"Allocated ProvisionedConcurrentExecutions": 0,
"Status": "IN_PROGRESS",
"LastModified": "2019-11-21T19:32:12+0000"
}

Para configurar Auto Scaling de aplicaciones para administrar la concurrencia aprovisionada, utilice Auto
Scaling de aplicaciones para configurar el escalado de seguimiento de destino. Primero, registre el alias
de una función como destino de escala. En el ejemplo siguiente se registra el alias BLUE de una función
denominada my-function:

$ aws application-autoscaling register-scalable-target --service-namespace lambda \

--resource-id function:my-function:BLUE --min-capacity 1 --max-capacity 100 \
--scalable-dimension lambda:function:ProvisionedConcurrency

A continuación, aplique una política de escalado al destino. El ejemplo siguiente se configura Auto Scaling
de aplicaciones para ajustar la configuración de simultaneidad aprovisionada para que un alias mantenga
la utilización cerca del 70 por ciento:

$ aws application-autoscaling put-scaling-policy --service-namespace lambda \

--scalable-dimension lambda:function:ProvisionedConcurrency --resource-id function:my-
function:BLUE \
--policy-name my-policy --policy-type TargetTrackingScaling \
--target-tracking-scaling-policy-configuration '{ "TargetValue":
0.7, "PredefinedMetricSpecification": { "PredefinedMetricType":
"LambdaProvisionedConcurrencyUtilization" }}'
{
"PolicyARN": "arn:aws:autoscaling:us-east-2:123456789012:scalingPolicy:12266dbb-1524-
xmpl-a64e-9a0a34b996fa:resource/lambda/function:my-function:BLUE:policyName/my-policy",
"Alarms": [
{
"AlarmName": "TargetTracking-function:my-function:BLUE-AlarmHigh-aed0e274-
xmpl-40fe-8cba-2e78f000c0a7",
"AlarmARN": "arn:aws:cloudwatch:us-east-2:123456789012:alarm:TargetTracking-
function:my-function:BLUE-AlarmHigh-aed0e274-xmpl-40fe-8cba-2e78f000c0a7"
},
{
"AlarmName": "TargetTracking-function:my-function:BLUE-AlarmLow-7e1a928e-
xmpl-4d2b-8c01-782321bc6f66",
"AlarmARN": "arn:aws:cloudwatch:us-east-2:123456789012:alarm:TargetTracking-
function:my-function:BLUE-AlarmLow-7e1a928e-xmpl-4d2b-8c01-782321bc6f66"
}
]
}

Auto Scaling de aplicaciones crea dos alarmas en CloudWatch. La primera alarma se activa cuando
la utilización de la simultaneidad aprovisionada supera sistemáticamente el 70 por ciento. Cuando
esto sucede, Auto Scaling de aplicaciones asigna más simultaneidad aprovisionada para reducir esta
utilización. La segunda alarma se activa cuando la utilización es consistentemente inferior al 63 por
ciento (90 % del objetivo del 70 por ciento). Cuando esto sucede, Auto Scaling de aplicaciones reduce la
concurrencia aprovisionada del alias.

En el siguiente ejemplo, una función escala entre cantidades mínimas y máximas de simultaneidad
aprovisionada basada en su uso. Cuando el número de solicitudes abiertas aumenta, Auto Scaling
de aplicaciones aumenta la simultaneidad aprovisionada a pasos grandes hasta que llega al máximo
configurado. La función sigue escalando en simultaneidad estándar hasta que su uso comienza a

66
 AWS Lambda Guía para desarrolladores
Configuración de simultaneidad con la API de Lambda

disminuir. Cuando el uso es consistentemente bajo, Auto Scaling de aplicaciones reduce la simultaneidad
aprovisionada en pasos periódicos más pequeños.

Leyenda

• Instancias de función
• Solicitudes abiertas
• Simultaneidad aprovisionada
• Simultaneidad estándar

Para ver los límites de simultaneidad de su cuenta en una región, utilice get-account-settings.

$ aws lambda get-account-settings

{

67
 AWS Lambda Guía para desarrolladores
Versiones

"AccountLimit": {
"TotalCodeSize": 80530636800,
"CodeSizeUnzipped": 262144000,
"CodeSizeZipped": 52428800,
"ConcurrentExecutions": 1000,
"UnreservedConcurrentExecutions": 900
},
"AccountUsage": {
"TotalCodeSize": 174913095,
"FunctionCount": 52
}
}

Versiones de funciones de AWS Lambda

Puede usar versiones para administrar la implementación de sus funciones de AWS Lambda. Por ejemplo,
puede publicar una nueva versión de una función para pruebas beta sin afectar a los usuarios de la versión
de producción estable.

El sistema crea una nueva versión de la función de Lambda cada vez que se publica la función. La nueva
versión es una copia de la versión no publicada de la función. La versión de la función incluye la siguiente
información:

• El código de función y todas las dependencias asociadas.

• El tiempo de ejecución de Lambda que ejecuta la función.
• Todos los ajustes de la función, incluidas las variables de entorno.
• Un nombre de recurso de Amazon (ARN) único para identificar esta versión de la función.

Puede cambiar el código y la configuración de la función solo en la versión no publicada de una función.
Cuando se publica una versión, el código y la mayoría de las opciones de configuración se bloquean para
garantizar una experiencia uniforme para los usuarios de dicha versión. Para obtener más información
acerca de la configuración de funciones, consulte Configuración de funciones en la consola de AWS
Lambda (p. 52).

Para crear una nueva versión de una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija la función que desea publicar.
3. En Actions (Acciones), elija Publish new version (Publicar nueva versión).

Después de publicar la primera versión de una función, la consola de Lambda muestra un menú
desplegable con las versiones disponibles. El panel Designer (Diseñador) muestra un calificador de versión
al final del nombre de la función.

68
 AWS Lambda Guía para desarrolladores
Administración de versiones con la API de Lambda

Para ver las versiones actuales de la función, elija una función y, a continuación, elija Qualifiers
(Calificadores). En el menú Qualifiers (Cualificadores) ampliado, elija la pestaña Versions (Versiones). El
panel Versions (Versiones) muestra la lista de versiones de la función seleccionada. Si no ha publicado
una versión de la función seleccionada, el panel Versions (Versiones) muestra solo la versión $LATEST.

Administración de versiones con la API de Lambda

Para publicar una versión de una función, utilice la acción de la API PublishVersion (p. 563).

El siguiente ejemplo publica una nueva versión de una función. La respuesta devuelve la información de
configuración sobre la nueva versión, incluido el número de la versión y el ARN de la función con el sufijo
de la versión.

$ aws lambda publish-version --function-name my-function

{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"Runtime": "nodejs12.x",
...
}

Uso de versiones
El ARN permite hacer referencia a la función de Lambda. Existen dos ARN asociados a esta versión inicial:

69
 AWS Lambda Guía para desarrolladores
Políticas de recursos

• ARN completo: el ARN de la función con el sufijo de la versión.

arn:aws:lambda:aws-region:acct-id:function:helloworld:$LATEST

• ARN incompleto: el ARN de la función sin el sufijo de la versión.

arn:aws:lambda:aws-region:acct-id:function:helloworld

Puede utilizar este ARN incompleto en todas las operaciones pertinentes. Sin embargo, no puede
utilizarlo para crear un alias.

Si decide no publicar versiones de funciones, puede utilizar el ARN calificado o no calificado en el mapeo
de origen de eventos para invocar la función.

Lambda solo publica una nueva versión de función si el código no se ha publicado nunca o si el código
ha cambiado en comparación con la versión publicada más recientemente. Si no hay ningún cambio, la
versión de la función permanece en la versión publicada más recientemente.

Cada versión de función de Lambda tiene un ARN único. Después de publicar una versión, no puede
cambiar el ARN o el código de función.

Políticas de recursos
Cuando se utiliza una política basada en recursos (p. 36) para dar un servicio, recurso o acceso a cuentas
a su función, el alcance de dicho permiso depende de si se aplicó a una función o a una versión de una
función:

• Si utiliza un nombre de función calificado (como helloworld:1), el permiso es válido para invocar la
versión 1 de la función helloworld utilizando únicamente su ARN calificado. El uso de cualquier otro
ARN genera un error de permiso.
• Si utiliza un nombre de función no calificado (como helloworld), el permiso solo es válido para invocar
la función helloworld utilizando el ARN de la función no calificada. El uso de cualquier otro ARN,
incluido $LATEST, produce un error de permiso.
• Si utiliza el nombre de función calificado $LATEST (como helloworld:$LATEST), el permiso es válido
para invocar la función helloworld solo utilizando su ARN calificado. El uso de un ARN no calificado
genera un error de permiso.

Puede simplificar la administración de orígenes de eventos y políticas de recursos mediante el uso de alias
de función. Para obtener más información, consulte Alias de función de AWS Lambda (p. 70).

Alias de función de AWS Lambda

Puede crear uno o varios alias para una función de AWS Lambda. Un alias de Lambda es como un puntero
a una versión específica de una función de Lambda. Los usuarios pueden acceder a la versión de la
función utilizando el ARN de alias.

Para crear un alias

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Actions (Acciones), elija Create alias (Crear alias).

70
 AWS Lambda Guía para desarrolladores
Administración de alias con la API de Lambda

4. En el formulario Create a new alias (Crear un nuevo alias), escriba un nombre para el alias y una
descripción opcional. Elija la versión de la función para este alias.

Para ver los alias definidos actualmente para una función, elija Qualifiers (Calificadores) y elija la pestaña
Alias .

Administración de alias con la API de Lambda

Para crear un alias, utilice el comando create-alias.

$ aws lambda create-alias --function-name my-function --name alias-name --function-

version version-number --description " "

Para cambiar un alias para apuntar a una nueva versión de la función, utilice el comando update-alias.

$ aws lambda update-alias --function-name my-function --name alias-name --function-

version version-number

Los comandos de la AWS CLI de los pasos anteriores corresponden a las siguientes API de AWS Lambda:

• CreateAlias (p. 456)

• UpdateAlias (p. 588)

Uso de alias
Cada alias tiene un ARN único. Un alias solo puede apuntar a una versión de función, no a otro alias.
Puede actualizar un alias para que apunte a una nueva versión de la función.

Fuentes de eventos como Amazon S3 invocan su función de Lambda. Estos orígenes de eventos
mantienen un mapeo que identifica la función que invocarán cuando se produzcan eventos. Si especifica
un alias de función de Lambda en la configuración de asignación, no es necesario actualizar el mapeo
cuando cambie la versión de la función.

En una política de recursos, puede conceder permisos para que los orígenes de eventos utilicen la función
de Lambda. Si especifica un ARN de alias en la política, no es necesario que actualice la política cuando
cambie la versión de la función.

71
 AWS Lambda Guía para desarrolladores
Políticas de recursos

Políticas de recursos
Cuando se utiliza una política basada en recursos (p. 36) para dar un servicio, recurso o acceso a cuentas
a su función, el alcance de dicho permiso depende de si se aplicó a un alias, a una versión o a la función.
Si utiliza un nombre de alias (como helloworld:PROD), el permiso solo es válido para invocar la función
helloworld utilizando el ARN del alias. Obtiene un error de permiso si utiliza un ARN de versión o un
ARN de función. Esto incluye el ARN de versión al que apunta el alias.

Por ejemplo, el siguiente comando de AWS CLI otorga permisos a Amazon S3 para invocar el alias PROD
de la función de Lambda helloworld. Tenga en cuenta que el parámetro --qualifier especifica el
nombre del alias.

$ aws lambda add-permission --function-name helloworld \

--qualifier PROD --statement-id 1 --principal [Link] --action
lambda:InvokeFunction \
--source-arn arn:aws:s3:::examplebucket --source-account 123456789012

En este caso, Amazon S3 ahora puede invocar el alias PROD. Lambda puede ejecutar la versión de
la función de Lambda helloworld a la que hace referencia el alias PROD. Para que esto funcione
correctamente, debe utilizar el ARN del alias PROD en la configuración de notificaciones del bucket de S3.

Configuración de direccionamiento de alias

Utilice la configuración de direccionamiento en un alias para enviar una parte del tráfico a una segunda
versión de función. Por ejemplo, puede reducir el riesgo de implementar una nueva versión configurando el
alias para enviar la mayor parte del tráfico a la versión existente y solo un pequeño porcentaje del tráfico a
la nueva versión.

Puede apuntar un alias a un máximo de dos versiones de una función de Lambda. Las versiones deben
cumplir los siguientes criterios:

• Ambas versiones deben tener el mismo rol de ejecución de IAM.

• Ambas versiones deben tener la misma configuración de cola de mensajes fallidos o ninguna
configuración de cola de mensajes fallidos.
• Ambas versiones deben publicarse. El alias no puede apuntar a $LATEST.

Para configurar el direccionamiento en un alias

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Verifique que la función tenga al menos dos versiones publicadas. Para ello, elija Qualifiers
(Calificadores) y, a continuación, elija Versions (Versiones) para mostrar la lista de versiones. Si
necesita crear versiones adicionales, siga las instrucciones de Versiones de funciones de AWS
Lambda (p. 68).
4. En el menú Actions (Acciones), elija Create alias (Crear alias).
5. En la ventana Create a new alias (Crear un nuevo alias), escriba un valor para Name (Nombre),
opcionalmente escriba un valor para Description (Descripción) y elija la Version (Versión) de la función
de Lambda a la que hace referencia el alias.
6. En Additional version (Versión adicional), especifique los elementos siguientes:

a. Elija la segunda versión de la función de Lambda.

b. Escriba un valor de ponderación para la función. La ponderación es el porcentaje de tráfico que
se asigna a dicha versión cuando se invoca el alias. La primera versión recibe la ponderación

72
 AWS Lambda Guía para desarrolladores
Configuración de direccionamiento de alias

residual. Por ejemplo, si especifica un 10 por ciento en Additional version (Versión adicional), a la
primera versión se asigna automáticamente el 90 %.
7. Seleccione Create.

Configuración de direccionamiento de alias

Utilice los comandos create-alias y update-alias para configurar las ponderaciones de tráfico entre
dos versiones de funciones. Cuando se crea o actualiza el alias, se especifica la ponderación del tráfico en
el parámetro routing-config.

En el ejemplo siguiente se crea un alias (denominado alias de direccionamiento) para una función de
Lambda. El alias apunta a la versión 1 de la función. La versión 2 de la función recibe el 3 por ciento del
tráfico. El 97 por ciento restante del tráfico se dirige a la versión 1.

$ aws lambda create-alias --name routing-alias --function-name my-function --function-

version 1 \
--routing-config AdditionalVersionWeights={"2"=0.03}

Utilice el comando update-alias para aumentar el porcentaje de tráfico entrante a la versión 2. En el

ejemplo siguiente, aumenta el tráfico al 5 por ciento.

$ aws lambda update-alias --name routing-alias --function-name my-function \

--routing-config AdditionalVersionWeights={"2"=0.05}

Para dirigir todo el tráfico a la versión 2, utilice el comando UpdateAlias para cambiar la propiedad
function-version y dirigir el alias a la versión 2. El comando también restablece la configuración de
direccionamiento.

$ aws lambda update-alias --name routing-alias --function-name my-function \

--function-version 2 --routing-config AdditionalVersionWeights={}

Los comandos de la CLI en los pasos anteriores corresponden a las siguientes operaciones de la API de
AWS Lambda:

• CreateAlias (p. 456)

• UpdateAlias (p. 588)

Cómo saber qué versión se ha invocado

Al configurar las ponderaciones de tráfico entre dos versiones de función, hay dos formas de determinar la
versión de la función de Lambda que se ha invocado:

• CloudWatch Logs: Lambda emite automáticamente una entrada de registro START que contiene el ID de
la versión invocada a CloudWatch Logs para cada invocación de función. A continuación se muestra un
ejemplo:

19:44:37 START RequestId: request id Version: $version

Para invocaciones de alias, Lambda utiliza la dimensión Executed Version para filtrar los datos de
las métricas por la versión ejecutada. Para obtener más información, consulte Trabajar con métricas de
función de AWS Lambda (p. 400).
• Carga de respuesta (invocaciones sincrónicas): las respuestas a invocaciones de funciones sincrónicas
incluyen un encabezado x-amz-executed-version para indicar qué versión de función se ha
invocado.

73
 AWS Lambda Guía para desarrolladores
Capas

Capas de AWS Lambda

Puede configurar la función de Lambda para incorporar código y contenido adicional en forma de capas.
Una capa es un archivo ZIP que contiene bibliotecas, un tiempo de ejecución personalizado (p. 121) u
otras dependencias. Con las capas, puede utilizar las bibliotecas en la función sin necesidad de incluirlas
en el paquete de implementación.

Las capas le permiten mantener un tamaño pequeño para el paquete de implementación, lo que facilita la
implementación. Puede evitar errores que podrían producirse al instalar y empaquetar dependencias con el
código de la función. Para las funciones [Link], Python y Ruby, puede desarrollar el código de su función
en la consola de Lambda (p. 6) siempre que mantenga el paquete de implementación en 3 MB.
Note

Una función puede utilizar hasta 5 capas a la vez. El tamaño total descomprimido de la función
y todas las capas no puede superar el límite del tamaño del paquete de implementación sin
comprimir, de 250 MB. Para obtener más información, consulte Límites de AWS Lambda (p. 30).

Puede crear capas o utilizar capas publicadas por AWS y otros clientes de AWS. Las capas admiten
políticas basadas en recursos (p. 78) para conceder permisos de uso por capas a cuentas específicas
de AWS o de AWS Organizations o a todas las cuentas.

Las capas se extraen en el directorio /opt en el entorno de ejecución de la función. Cada tiempo de
ejecución busca las bibliotecas en una ubicación diferente dentro de /opt, en función del lenguaje.
Estructure su capa (p. 77) de modo que el código de la función pueda acceder a las bibliotecas sin
configuración adicional.

También puede utilizar Modelo de aplicación sin servidor de AWS (AWS SAM) para administrar las capas y
la configuración de la capa de su función. Para obtener instrucciones, consulte Declaración de recursos sin
servidor en la Guía para desarrolladores de Modelo de aplicación sin servidor de AWS.

Secciones
• Configuración de una función para usar capas (p. 74)
• Administración de capas (p. 75)
• Inclusión de dependencias de biblioteca en una capa (p. 77)
• Permisos de capa (p. 78)

Configuración de una función para usar capas

Puede especificar hasta 5 capas en la configuración de la función, durante o después de la creación de la
función. Elige una versión específica de una capa para usarla. Si desea utilizar una versión diferente más
tarde, puede actualizar la configuración de la función.

Para agregar capas a su función, utilice el comando update-function-configuration. En el

siguiente ejemplo se añaden dos capas: una desde la misma cuenta que la función y una desde una
cuenta diferente.

$ aws lambda update-function-configuration --function-name my-function \

--layers arn:aws:lambda:us-east-2:123456789012:layer:my-layer:3
\
arn:aws:lambda:us-east-2:210987654321:layer:their-layer:2
{
"FunctionName": "test-layers",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",

74
 AWS Lambda Guía para desarrolladores
Administración de capas

"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/service-role/lambda-role",
"Layers": [
{
"Arn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:3",
"CodeSize": 169
},
{
"Arn": "arn:aws:lambda:us-east-2:210987654321:layer:their-layer:2",
"CodeSize": 169
}
],
"RevisionId": "81cc64f5-5772-449a-b63e-12330476bcc4",
...
}

Debe especificar la versión de cada capa que quiera utilizar proporcionando el ARN completo de la versión
de la capa. Al añadir capas para una función que ya tenga capas, la nueva lista sobrescribe la anterior.
Incluya todas las capas cada vez que actualice la configuración de la capa. Para eliminar todas las capas,
especifique una lista vacía.

$ aws lambda update-function-configuration --function-name my-function --layers []

Su función puede obtener acceso al contenido de la capa durante la ejecución en el directorio /opt. Las
capas se aplican en el orden que se especifica y se combinan las carpetas con el mismo nombre. Si el
mismo archivo aparece en varias capas, se utiliza la versión en la última capa aplicada.

El creador de una capa puede eliminar la versión de la capa que esté utilizando. Cuando esto sucede, la
función continúa ejecutándose como si la versión de la capa siguiera existiendo. Sin embargo, cuando
actualiza la configuración de la capa, debe eliminar la referencia a la versión eliminada.

Administración de capas
Para crear una capa, use el comando publish-layer-version con un nombre, una descripción, un
archivo ZIP y una lista de tiempos de ejecución (p. 118) que sean compatibles con la capa. La lista de
tiempos de ejecución es opcional, pero hace que la capa sea más fácil de descubrir.

$ aws lambda publish-layer-version --layer-name my-layer --description "My layer" --

license-info "MIT" \
--content S3Bucket=lambda-layers-us-east-2-123456789012,S3Key=[Link] --compatible-
runtimes python3.6 python3.7
{
"Content": {
"Location": "[Link]
snapshots/123456789012/my-layer-4aaa2fbb-ff77-4b0a-ad92-5b78a716a96a?
versionId=27iWyA73cCAYqyH...",
"CodeSha256": "tv9jJO+rPbXUUXuRKi7CwHzKtLDkDRJLB3cC3Z/ouXo=",
"CodeSize": 169
},
"LayerArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer",
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:1",
"Description": "My layer",
"CreatedDate": "2018-11-14T23:03:52.894+0000",
"Version": 1,
"LicenseInfo": "MIT",
"CompatibleRuntimes": [
"python3.6",
"python3.7",
"python3.8"
]

75
 AWS Lambda Guía para desarrolladores
Administración de capas

Cada vez que llame a publish-layer-version crea una nueva versión. Las funciones que utilizan
la capa se refieren directamente a una versión de la capa. Puede configurar permisos (p. 78) en una
versión de la capa existente, pero para realizar cualquier otro cambio, debe crear una nueva versión.

Para encontrar capas que sean compatibles con el tiempo de ejecución de su función, utilice el comando
list-layers.

$ aws lambda list-layers --compatible-runtime python3.8

{
"Layers": [
{
"LayerName": "my-layer",
"LayerArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer",
"LatestMatchingVersion": {
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-
layer:2",
"Version": 2,
"Description": "My layer",
"CreatedDate": "2018-11-15T00:37:46.592+0000",
"CompatibleRuntimes": [
"python3.6",
"python3.7",
"python3.8",
]
}
}
]
}

Puede omitir la opción del tiempo de ejecución para obtener una lista de todas las capas. Los detalles en
la respuesta reflejan la versión más reciente de la capa. Consulte todas las versiones de una capa con
list-layer-versions. Para obtener más información sobre una versión, utilice get-layer-version.

$ aws lambda get-layer-version --layer-name my-layer --version-number 2

{
"Content": {
"Location": "[Link]
snapshots/123456789012/my-layer-91e9ea6e-492d-4100-97d5-a4388d442f3f?
versionId=GmvPV.309OEpkfN...",
"CodeSha256": "tv9jJO+rPbXUUXuRKi7CwHzKtLDkDRJLB3cC3Z/ouXo=",
"CodeSize": 169
},
"LayerArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer",
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
"Description": "My layer",
"CreatedDate": "2018-11-15T00:37:46.592+0000",
"Version": 2,
"CompatibleRuntimes": [
"python3.6",
"python3.7",
"python3.8"
]
}

El enlace en la respuesta le permite descargar el archivo de la capa y es válido durante 10 minutos. Para
eliminar una versión de una capa, use el comando delete-layer-version.

$ aws lambda delete-layer-version --layer-name my-layer --version-number 1

76
 AWS Lambda Guía para desarrolladores
Inclusión de dependencias de biblioteca en una capa

Al eliminar una versión de una capa, ya no puede configurar funciones para usarla. Sin embargo, cualquier
función que ya utilice la versión sigue teniendo acceso a la misma. Los números de versión nunca se
reutilizan para un nombre de capa.

Inclusión de dependencias de biblioteca en una capa

Puede trasladar las dependencias de tiempo de ejecución fuera del código de la función colocándolas en
una capa. Los tiempos de ejecución de Lambda incluyen rutas en el directorio /opt para garantizar que el
código de la función tenga acceso a las bibliotecas incluidas en las capas.

Para incluir bibliotecas en una capa, colóquelas en una de las carpetas que admita el tiempo de ejecución.

• [Link] – nodejs/node_modules, nodejs/node8/node_modules (NODE_PATH)

Example SDK de AWS X-Ray para [Link]

[Link]
# nodejs/node_modules/aws-xray-sdk

• Python: python, python/lib/python3.8/site-packages (directorios de sitio)

Example Pillow

[Link]
# python/PIL
# python/[Link]-info

• Java – java/lib (classpath)

Example Jackson

[Link]
# java/lib/[Link]

• Ruby – ruby/gems/2.5.0 (GEM_PATH), ruby/lib (RUBY_LIB)

Example JSON

[Link]
# ruby/gems/2.5.0/
| build_info
| cache
| doc
| extensions
| gems
| # json-2.1.0
# specifications
# [Link]

• Todas – bin (PATH), lib (LD_LIBRARY_PATH)

Example JQ

[Link]
# bin/jq

77
 AWS Lambda Guía para desarrolladores
Permisos de capa

Para obtener más información acerca de la configuración de rutas en el entorno de ejecución de Lambda,
consulte Variables de entorno de tiempo de ejecución (p. 56).

Permisos de capa
Los permisos de uso de capa se administran en el recurso. Para configurar una función con una capa,
necesita permiso para llamar a GetLayerVersion en la versión de la capa. Para las funciones en su
cuenta, puede obtener este permiso desde su política de usuario (p. 41) o desde la política basada en
recursos (p. 36) de la función. Para utilizar una capa en otra cuenta, necesita permiso en su política de
usuario, y el propietario de la otra cuenta debe conceder permiso a su cuenta con una política basada en
recursos.

Para conceder el permiso de uso de capa a otra cuenta, añada una instrucción a la política de permisos de
la versión de la capa con el comando add-layer-version-permission. En cada instrucción, puede
conceder permiso a una única cuenta, a todas las cuentas o a una organización.

$ aws lambda add-layer-version-permission --layer-name xray-sdk-nodejs --statement-id

xaccount \
--action lambda:GetLayerVersion --principal 210987654321 --version-number 1 --output text
e210ffdc-e901-43b0-824b-5fcd0dd26d16 {"Sid":"xaccount","Effect":"Allow","Principal":
{"AWS":"arn:aws:iam::210987654321:root"},"Action":"lambda:GetLayerVersion","Resource":"arn:aws:lambda:u
east-2:123456789012:layer:xray-sdk-nodejs:1"}

Los permisos solo se aplican a una única versión de una capa. Repita el procedimiento cada vez que cree
una nueva versión de la capa.

Para ver más ejemplos, consulte Concesión de acceso a las capas a otras cuentas (p. 40).

Configuración de una función Lambda para obtener

acceso a los recursos en una VPC
Puede configurar una función para conectarse a subredes privadas en una nube virtual privada (VPC) de
su cuenta. Utilice Amazon Virtual Private Cloud (Amazon VPC) para crear una red privada para recursos
como bases de datos, instancias de caché o servicios internos. Conecte la función a la VPC para tener
acceso a recursos privados durante su ejecución.

Para conectar una función a una VPC

1. Abra la consola de Lambda.

2. Elija una función.
3. En VPC, elija Edit (Editar).
4. Elija Custom VPC (VPC personalizada).
5. Elija una VPC, las subredes y los grupos de seguridad.
Note

Conecte la función a subredes privadas para acceder a recursos privados. Si la función

necesita acceso a Internet, use NAT (p. 80). Conectar una función a una subred pública no
le concede acceso a Internet ni una dirección IP pública.
6. Elija Save (Guardar).

Al conectar una función a una VPC, Lambda crea una interfaz de red elástica para cada combinación
de grupo de seguridad y subred en la configuración de la VPC de la función. Este proceso puede tardar

78
 AWS Lambda Guía para desarrolladores
Rol de ejecución y permisos de usuario

alrededor de un minuto. Durante este tiempo, no se pueden realizar operaciones adicionales que se dirijan
a la función, como la creación de versiones (p. 68) o la actualización del código de la función. Para las
nuevas funciones, no se pueden invocar hasta que su estado cambie de Pending a Active. Para las
funciones existentes, todavía puede seguir invocar la versión antigua mientras la actualización está en
curso. Para obtener más información acerca de las políticas de función, consulte Monitorización del estado
de una función con la API de Lambda (p. 101).

Varias funciones conectadas a las mismas subredes comparten interfaces de red, por lo que es mucho
más rápido conectar funciones adicionales a una subred que ya tiene una interfaz de red administrada
por Lambda. Sin embargo, Lambda puede crear interfaces de red adicionales si tiene muchas funciones o
funciones que se ejecutan muy a menudo.

Si las funciones no están activas durante un largo periodo de tiempo, Lambda recupera sus interfaces de
red y la función pasa a ser Idle. Invoque una función inactiva para reactivarla. Se produce un error en la
primera invocación y la función vuelve a cambiar a un estado pendiente hasta que la interfaz de red esté
disponible.

Las funciones de Lambda no pueden conectarse directamente a una VPC con tenencia de instancias
dedicadas. Para conectarse a los recursos de una VPC dedicada, interconéctela con una segunda VPC
con tenencia predeterminada.

Tutoriales de VPC

• Tutorial: Configuración de una función de Lambda para obtener acceso a Amazon RDS en una Amazon
VPC (p. 250)
• Tutorial: Configuración de una función de Lambda para obtener acceso a Amazon ElastiCache en una
Amazon VPC (p. 218)

Secciones
• Rol de ejecución y permisos de usuario (p. 79)
• Configuración del acceso a la Amazon VPC con la API de Lambda (p. 80)
• Acceso a Internet y a los servicios para funciones conectadas a la VPC (p. 80)
• Ejemplos de configuraciones de VPC (p. 81)

Rol de ejecución y permisos de usuario

Lambda utiliza los permisos de la función para crear y administrar interfaces de red. Para conectarse a una
VPC, el rol de ejecución de la función debe tener los siguientes permisos.

Permisos de rol de ejecución

• ec2:CreateNetworkInterface
• ec2:DescribeNetworkInterfaces
• ec2:DeleteNetworkInterface

Estos permisos están incluidos en la política administrada AWSLambdaVPCAccessExecutionRole.

Al configurar la conectividad de VPC, Lambda utiliza los permisos para comprobar los recursos de red.
Para configurar una función para conectarse a una VPC, su usuario de IAM necesita los siguientes
permisos.

Permisos de usuario

• ec2:DescribeSecurityGroups

79
 AWS Lambda Guía para desarrolladores
Configuración del acceso a la
Amazon VPC con la API de Lambda

• ec2:DescribeSubnets
• ec2:DescribeVpcs

Configuración del acceso a la Amazon VPC con la API

de Lambda
Puede conectar una función a una VPC con las siguientes API.

• CreateFunction (p. 466)

• UpdateFunctionConfiguration (p. 605)

Para conectar la función a una VPC cuando se crea con la AWS CLI, utilice la opción vpc-config con
una lista de identificadores de subred privada y grupos de seguridad. En el ejemplo siguiente se crea una
función con una conexión a una VPC con dos subredes y un grupo de seguridad.

$ aws lambda create-function --function-name my-function \

--runtime nodejs12.x --handler [Link] --zip-file fileb://[Link] \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config
SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb

Para conectar una función existente, utilice la opción vpc-config con el comando update-function-
configuration.

$ aws lambda update-function-configuration --function-name my-function \

--vpc-config
SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb

Para desconectar la función de de una VPC, actualice la configuración de la función con una lista vacía de
subredes y grupos de seguridad.

$ aws lambda update-function-configuration --function-name my-function \

--vpc-config SubnetIds=[],SecurityGroupIds=[]

Acceso a Internet y a los servicios para funciones

conectadas a la VPC
De forma predeterminada, Lambda ejecuta las funciones en una VPC segura con acceso a los servicios de
AWS e Internet. La VPC es propiedad de Lambda y no se conecta a la VPC predeterminada de su cuenta.
Al conectar una función a una VPC de su cuenta, esta no tiene acceso a Internet a menos que su VPC
proporcione acceso.
Note

Varios servicios ofrecen puntos de enlace de VPC. Puede utilizar los puntos de enlace de VPC
para conectarse a servicios de AWS desde dentro de una VPC sin acceso a Internet.

El acceso a Internet desde una subred privada requiere la conversión de las direcciones de red (NAT).
Para conceder a la función acceso a Internet, dirija el tráfico saliente a una gateway NAT en una subred
pública. La gateway NAT tiene una dirección IP pública y puede conectarse a Internet a través de la
gateway de Internet de la VPC. Para obtener más información, consulte Gateways NAT en la Guía del
usuario de Amazon VPC.

80
 AWS Lambda Guía para desarrolladores
Ejemplos de configuraciones de VPC

Ejemplos de configuraciones de VPC

Encontrará ejemplos de plantillas de AWS CloudFormation para configuraciones de VPC que podrá utilizar
con funciones de Lambda en el repositorio de GitHub de esta guía. Existen dos plantillas:

• [Link]: VPC con dos subredes privadas y puntos de enlace de VPC para Amazon Simple
Storage Service y Amazon DynamoDB. Puede utilizar esta plantilla para crear una VPC para funciones
que no necesitan acceso a Internet. Esta configuración admite el uso de Amazon S3 y DynamoDB con
el SDK de AWS, así como el acceso a los recursos de base de datos de la misma VPC a través de una
conexión de red local.
• [Link]: VPC con dos subredes privadas, puntos de enlace de VPC, una subred pública
con una gateway NAT y una gateway de Internet. El tráfico hacia Internet desde las funciones de las
subredes privadas se dirige a la gateway NAT mediante una tabla de enrutamiento.

Para utilizar una plantilla para crear una VPC, elija Create stack (Crear pila) en la consola de AWS
CloudFormation y siga las instrucciones.

Configuración del acceso a la base de datos para

una función Lambda
Puede utilizar la consola de Lambda para crear un proxy de base de datos de Amazon Relational
Database Service (Amazon RDS) para su función. Un proxy de base de datos administra un conjunto
de conexiones de base de datos y transmite consultas desde una función. Esto permite que una función
alcance altos niveles de simultaneidad (p. 18) sin agotar las conexiones de base de datos.

Para crear un proxy de base de datos

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Elija Add database proxy (Agregar proxy de base de datos).
4. Configure las siguientes opciones.

• Identificador de proxy: el nombre del proxy.

• Instancia de base de datos de RDS: una instancia o clúster de base de datos de MySQL 5.6 o
MySQL 5.7.
• Secreto: un secreto de Secrets Manager con el nombre de usuario y la contraseña de la base de
datos.

Example secreta

{
"username": "admin",
"password": "e2abcecxmpldc897"
}

• Rol de IAM: un rol de IAM con permiso para usar el secreto y una política de confianza que permite
a Amazon RDS asumir el rol.
5. Elija Add.

La creación de proxy tarda unos minutos. Cuando el proxy esté disponible, configure su función para que
se conecte al punto de enlace del proxy en lugar del punto de enlace de la base de datos.

81
 AWS Lambda Guía para desarrolladores
Aplicación de muestra

Para obtener más información, consulte Administración de conexiones con el proxy de Amazon RDS en la
Guía del usuario de Amazon Aurora.

Aplicación de muestra
Las aplicaciones de muestra que presentan el uso de Lambda con una base de datos de Amazon RDS
están disponibles en el repositorio GitHub de esta guía. Hay dos aplicaciones:

• RDS MySQL: la plantilla de AWS CloudFormation [Link] crea una base de datos
de MySQL 5.7 en una VPC privada. En la aplicación de muestra, una función Lambda intercepta las
consultas a la base de datos. Tanto la función como las plantillas de base de datos utilizan Secrets
Manager para obtener acceso a las credenciales de la base de datos.

• Administrador de listas: una función del procesador lee los eventos de un flujo de Kinesis. Utiliza los
datos de los eventos para actualizar las tablas de DynamoDB y almacena una copia del evento en una
base de datos de MySQL.

82
 AWS Lambda Guía para desarrolladores
Etiquetas

Para utilizar las aplicaciones de muestra, siga las instrucciones del repositorio GitHub: RDS MySQL,
Administrador de listas.

Etiquetado de funciones de Lambda

Puede etiquetar funciones Lambda para organizarlas por propietario, proyecto o departamento. Las
etiquetas son pares clave-valor de forma libre que se pueden utilizar en diferentes servicios de AWS para
filtrar recursos y agregar detalles a los informes de facturación.

Para agregar etiquetas a una función

1. Abra la página Functions (Funciones) en la consola de Lambda.

83
 AWS Lambda Guía para desarrolladores
Etiquetas

2. Elija una función.

3. En Tags (Etiquetas), elija Manage tags (Administrar etiquetas).
4. Introduzca una clave y un valor. Para agregar otras etiquetas, elija Add new tag (Agregar nueva
etiqueta).

5. Elija Save (Guardar).

Puede filtrar las funciones en función de la presencia o el valor de una etiqueta utilizando la consola de
Lambda o la API de Grupos de recursos de AWS. Las etiquetas se aplican en el nivel de las funciones,
no de las versiones ni de los alias. Las etiquetas no forman parte de la configuración específica de la
instantánea que se crea al publicar una versión.

Para filtrar funciones con etiquetas

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Haga clic dentro de la barra de búsqueda para ver una lista de los atributos de función y las claves de
etiqueta.

3. Elija una clave de etiqueta para ver la lista de valores que están en uso en la región actual.

84
 AWS Lambda Guía para desarrolladores
Uso de etiquetas con AWS CLI

4. Elija un valor para ver las funciones con ese valor o elija (all values) [(todos los valores)] para ver
todas las funciones que tienen una etiqueta con esa clave.

La barra de búsqueda también permite buscar claves de etiqueta. Escriba tag para ver exclusivamente
una lista de claves de etiqueta o comience a escribir el nombre de una clave para encontrarla en la lista.

Con AWS Billing and Cost Management, puede utilizar etiquetas para personalizar los informes de
facturación y crear informes de asignación de costos. Para obtener más información, consulte Informe
de asignación de costos mensual y Uso de etiquetas de asignación de costos en la Guía del usuario de
administración de costos y facturación de AWS.

Secciones
• Uso de etiquetas con AWS CLI (p. 85)
• Requisitos de las claves y los valores de las etiquetas (p. 86)

Uso de etiquetas con AWS CLI

Al crear una función de Lambda, puede incluir etiquetas con la opción --tags.

$ aws lambda create-function --function-name my-function

--handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-role \
--tags Department=Marketing,CostCenter=1234ABCD

Para añadir etiquetas a una función existente, utilice el comando tag-resource.

$ aws lambda tag-resource \

--resource arn:aws:lambda:us-east-2:123456789012:function:my-function \
--tags Department=Marketing,CostCenter=1234ABCD

Para eliminar etiquetas, utilice el comando untag-resource.

$ aws lambda untag-resource --resource function arn \

--tag-keys Department

Si desea ver las etiquetas que se aplican a una función de Lambda específica, puede utilizar cualquiera de
los siguientes comandos de la API de Lambda:

• ListTags (p. 554) – proporcione el ARN (nombre de recurso de Amazon de la función de Lambda para
ver una lista de las etiquetas asociadas a esta función:

85
 AWS Lambda Guía para desarrolladores
Requisitos de las claves y los valores de las etiquetas

$ aws lambda list-tags --resource function arn

• GetFunction (p. 500) – proporcione el nombre de la función de Lambda para ver una lista de las
etiquetas asociadas a esta función:

$ aws lambda get-function --function-name my-function

También puede utilizar la API GetResources de AWS Tagging Service para filtrar los recursos por
etiquetas. La API GetResources admite hasta 10 filtros, y cada uno contiene una clave de etiqueta y hasta
10 valores de etiqueta. Proporcione a GetResources un valor “ResourceType” si desea filtrar por tipos de
recurso específicos. Para obtener más información acerca de AWS Tagging Service, consulte Uso de los
grupos de recursos.

Requisitos de las claves y los valores de las etiquetas

Los siguientes requisitos se aplican a las etiquetas:

• Número máximo de etiquetas por recurso: 50

• Longitud máxima de la clave: 128 caracteres Unicode en UTF-8
• Longitud máxima del valor: 256 caracteres Unicode en UTF-8
• Las claves y los valores de las etiquetas distinguen entre mayúsculas y minúsculas.
• No utilice el prefijo aws: en los nombres o valores de las etiquetas, porque está reservado para uso de
AWS. Los nombres y valores de etiquetas que tienen este prefijo no se pueden editar. Las etiquetas que
tengan este prefijo no cuentan para el límite de etiquetas por recurso.
• Si se va utilizar su esquema de etiquetado en múltiples servicios y recursos, recuerde que otros servicios
pueden tener otras restricciones sobre caracteres permitidos. Los caracteres generalmente permitidos
son: letras, espacios y números representables en UTF-8, además de los siguientes caracteres
especiales: + - = . _ : / @.

86
 AWS Lambda Guía para desarrolladores

Invocación de funciones de AWS

Lambda
Puede invocar funciones de Lambda directamente con la consola de Lambda, la API de Lambda, el SDK
de AWS, la AWS CLI de AWS y los conjuntos de herramientas de AWS. También puede configurar otros
servicios de AWS para invocar la función o puede configurar Lambda para leer desde una transmisión o
cola e invocar la función.

Al invocar una función, puede optar por invocarla de forma síncrona o asíncrona. Con invocación
síncrona (p. 88), espere la función para procesar el evento y devolver una respuesta. Con invocación
asíncrona (p. 89), Lambda pone en cola el evento para su procesamiento y devuelve una respuesta
inmediatamente. Para invocación asíncrona, Lambda gestiona los reintentos y puede enviar registros de
invocación a un destino (p. 92).

Para utilizar su función para procesar datos automáticamente, agregue uno o más disparadores. Un
disparador es un recurso de Lambda o un recurso de otro servicio que se configura para invocar la
función en respuesta a eventos del ciclo de vida, solicitudes externas o en una programación. Su función
puede tener varios disparadores. Cada disparador actúa como un cliente invocando su función de forma
independiente. Cada evento que Lambda pasa a su función solo tiene datos de un cliente o disparador.

Para procesar elementos de una transmisión o una cola, puede crear un mapeo de origen de
eventos (p. 97). Un mapeo de origen de eventos es un recurso en Lambda que lee los elementos de
una cola de Amazon SQS, una transmisión de Amazon Kinesis o una transmisión de Amazon DynamoDB
y los envía a su función en lotes. Cada evento que su función procesa puede contener cientos o miles de
elementos.

Otros servicios y recursos de AWS invocan la función directamente. Por ejemplo, puede configurar Eventos
de CloudWatch para invocar la función en un temporizador o Amazon S3 para invocar la función cuando
se crea un objeto. Cada servicio varía en el método que utiliza para invocar la función, la estructura del
evento, y la forma de configurarla. Para obtener más información, consulte Uso de AWS Lambda con otros
servicios (p. 153).

Dependiendo de quién invoca la función y cómo se invoca, el comportamiento de escalado y los tipos
de errores que ocurren pueden varían. Al invocar una función sincrónicamente, recibe errores en la
respuesta y puede volver a intentarlo. Al invocar de forma asíncrona, utilizar un mapeo de origen de
eventos o configurar otro servicio para invocar su función, pueden variar los requisitos de reintentos y la
forma en que la función se escala para controlar un gran número de eventos. Para más detalles, consulte
Escalado de funciones de AWS Lambda (p. 102) y Control de errores y reintentos automáticos en AWS
Lambda (p. 107).

Temas
• Invocación síncrona (p. 88)
• Invocación asíncrona (p. 89)
• Mapeo de origen de eventos de AWS Lambda (p. 97)
• Monitorización del estado de una función con la API de Lambda (p. 101)
• Escalado de funciones de AWS Lambda (p. 102)
• Control de errores y reintentos automáticos en AWS Lambda (p. 107)
• Invocación de funciones de Lambda con el SDK de AWS Mobile para Android (p. 109)

87
 AWS Lambda Guía para desarrolladores
Invocación síncrona

Invocación síncrona
Al invocar una función sincrónicamente, Lambda ejecuta la función y espera una respuesta. Cuando
finaliza la ejecución de la función, Lambda devuelve la respuesta desde el código de la función con datos
adicionales como la versión de la función que se ejecutó. Para invocar una función de forma síncrona con
la AWS CLI, utilice el comando invoke.

$ aws lambda invoke --function-name my-function --payload '{ "key": "value" }'
[Link]
{
"ExecutedVersion": "$LATEST",
"StatusCode": 200
}

El siguiente diagrama muestra a los clientes que invocan una función Lambda de forma sincrónica.
Lambda envía los eventos directamente a la función y envía la respuesta de la función al invocador.

El payload es una cadena que contiene un evento en formato JSON. El nombre del archivo donde AWS
CLI escribe la respuesta de la función es [Link]. Si la función devuelve un objeto o error, la
respuesta es el objeto o error en formato JSON. Si la función sale sin errores, la respuesta es null.

La salida del comando, que se muestra en el terminal, incluye información de los encabezados en
la respuesta de Lambda. Esto incluye la versión que ha procesado el evento (útil cuando se utilizan
alias (p. 70)) y el código de estado devuelto por Lambda. Si Lambda pudo ejecutar la función, el código de
estado es 200, incluso aunque la función devolviera un error.
Note

Para funciones con un tiempo de espera largo, el cliente puede desconectarse durante la
invocación síncrona mientras espera una respuesta. Configure el cliente HTTP, SDK, el firewall, el
proxy o el sistema operativo para permitir conexiones largas con tiempo de espera o ajustes keep-
alive.

Si Lambda no puede ejecutar la función, el error se muestra en la salida.

$ aws lambda invoke --function-name my-function --payload value [Link]

An error occurred (InvalidRequestContentException) when calling the Invoke operation: Could
not parse request body into json: Unrecognized token 'value': was expecting ('true',
'false' or 'null')
at [Source: (byte[])"value"; line: 1, column: 11]

88
 AWS Lambda Guía para desarrolladores
Invocación asíncrona

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener más información acerca de la API Invoke, incluida una lista completa de parámetros,
encabezados y errores, consulte Invoke (p. 527).

Al invocar una función directamente, puede comprobar la respuesta en busca de errores y volver a
intentarlo. La AWS CLI y el SDK de AWS también reintentan automáticamente en los tiempos de espera,
limitaciones y errores de servicio del cliente. Para obtener más información, consulte Control de errores y
reintentos automáticos en AWS Lambda (p. 107).

Invocación asíncrona
Varios servicios de AWS, como Amazon Simple Storage Service (Amazon S3) y Amazon Simple
Notification Service (Amazon SNS), invocan funciones de forma ansíncrona para procesar eventos.
Cuando se invoca una función de forma asíncrona, no se espera una respuesta del código de función.
Se entrega el evento a Lambda, y Lambda se ocupa del resto. Puede configurar la forma en que Lambda
maneja los errores y puede enviar registros de invocación a un recurso descendente para encadenar los
componentes de la aplicación.

El siguiente diagrama muestra los clientes que invocan una función Lambda de forma asíncrona. Lambda
pone en cola los eventos antes de enviarlos a la función.

89
 AWS Lambda Guía para desarrolladores
Invocación asíncrona

Para la invocación asíncrona, Lambda coloca el evento en una cola y devuelve una respuesta de “proceso
realizado con éxito” sin información adicional. Un proceso independiente lee eventos de la cola y los envía
a la función. Para invocar una función de forma asíncrona, establezca el parámetro de tipo de invocación
en Event.

$ aws lambda invoke --function-name my-function --invocation-type Event --payload

'{ "key": "value" }' [Link]
{
"StatusCode": 202
}

El archivo de salida ([Link]) no contiene ninguna información, pero se crea al ejecutar este
comando. Si Lambda no puede añadir el caso a la cola, el mensaje de error aparece en la salida del
comando.

Lambda administra la cola de eventos asincrónica de la función y trata de reintentarlo en caso de errores.
Si la función devuelve un error, Lambda intenta ejecutarla dos veces más, con una espera de un minuto
entre los dos primeros intentos y dos minutos entre el segundo y el tercero. Los errores de la función
incluyen errores devueltos por el código de la función y los errores devueltos por el tiempo de ejecución de
la función, como, por ejemplo, los tiempos de espera.

90
 AWS Lambda Guía para desarrolladores
Invocación asíncrona

Si la función no tiene disponible suficiente simultaneidad para procesar todos los eventos, se limitan las
solicitudes adicionales. Para limitar errores (429) y errores del sistema (serie 500), Lambda devuelve
el evento a la cola e intenta ejecutar la función de nuevo durante un máximo de 6 horas. El intervalo de
reintento aumenta exponencialmente desde 1 segundo después del primer intento hasta un máximo de 5
minutos. Sin embargo, podría tardar más si se realiza una copia de seguridad de la cola. Lambda también
reduce la velocidad a la que lee eventos de la cola.

El siguiente ejemplo muestra un evento que se añadió correctamente a la cola, pero que aún está
pendiente una hora después debido a la restricción.

Aunque la función no devuelva un error, es posible que reciba el mismo evento de Lambda varias
veces, ya que la propia cola ofrece consistencia final. Si la función no es capaz de gestionar los eventos
entrantes, podrían también eliminarse de la cola sin que se envíen a la función. Asegúrese de que el
código de la función gestione sin problemas eventos duplicados y de que tenga simultaneidad suficiente
disponible para gestionar todas las invocaciones.

Cuando se realiza una copia de seguridad de la cola, es posible que los nuevos eventos se agoten
antes de que Lambda pueda enviarlos a la función. Cuando un evento caduca o todos los intentos de
procesamiento fallan, Lambda lo descarga. Puede configurar la gestión de errores (p. 92) de una
función para reducir el número de reintentos que realiza Lambda o para descartar eventos no procesados
más rápidamente.

También puede configurar Lambda para que envíe un registro de invocación a otro servicio. Lambda
admite los siguientes destinos (p. 92) para la invocación asincrónica.

• Amazon SQS: una cola de SQS.

• Amazon SNS: un tema de SNS.

91
 AWS Lambda Guía para desarrolladores
Configuración de la gestión de
errores para la invocación asincrónica

• AWS Lambda: una función Lambda.

• Amazon EventBridge: un bus de eventos de EventBridge.

El registro de invocación contiene detalles sobre la solicitud y la respuesta en formato JSON. Puede
configurar destinos independientes en eventos que se procesan con éxito, y eventos que fallan todos los
intentos de procesamiento. También puede configurar una cola de SQS o un tema de SNS como una cola
de mensajes fallidos (p. 95) para eventos descartados. En las colas de mensajes fallidos, Lambda solo
envía el contenido del evento, sin detalles sobre la respuesta.

Secciones
• Configuración de la gestión de errores para la invocación asincrónica (p. 92)
• Configuración de destinos para invocación asincrónica (p. 92)
• API de configuración de invocación asincrónica (p. 94)
• Colas de mensajes fallidos de funciones de AWS Lambda (p. 95)

Configuración de la gestión de errores para la

invocación asincrónica
Utilice la consola de Lambda para configurar los ajustes de gestión de errores en una función, una versión
o un alias.

Para configurar la gestión de errores

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Asynchronous invocation (Invocación asincrónica), elija Edit (Editar).
4. Configure los siguientes ajustes.

• Maximum age of event (Antigüedad máxima del evento): El período máximo de tiempo durante el
que Lambda retiene un evento en la cola de evento asincrónico, hasta 6 horas.
• Retry attempts (Número de reintentos): número de reintentos que Lambda realiza cuando la función
devuelve un error, entre 0 y 2.
5. Seleccione Save.

Cuando un evento de invocación supera la antigüedad máxima o no supera ningún reintento, Lambda lo
descarta. Para conservar una copia de eventos descartados, configure un destino de eventos fallidos.

Configuración de destinos para invocación asincrónica

Para enviar registros de invocaciones asincrónicas a otro servicio, añada un destino a su función. Puede
configurar destinos independientes para eventos que no superan el procesamiento y para eventos que se
procesan correctamente. Al igual que con los ajustes de gestión de errores, puede configurar los destinos
en una función, versión o alias.

El siguiente ejemplo muestra una función que está procesando invocaciones asincrónicas. Cuando
la función devuelve una respuesta correcta o sale sin lanzar un error, Lambda envía un registro de la
invocación a un bus de eventos EventBridge. Cuando un evento falla todos los intentos de procesamiento,
Lambda envía un registro de invocación a una cola de Amazon SQS.

92
 AWS Lambda Guía para desarrolladores
Configuración de destinos para invocación asincrónica

Para enviar eventos a un destino, su función necesita permisos adicionales. Añada una política con los
permisos necesarios al rol de ejecución (p. 32) de la función. Cada servicio de destino requiere un permiso
diferente, como se indica a continuación:

• Amazon SQS: sqs:SendMessage

• Amazon SNS: sns:Publish
• Lambda: lambda:InvokeFunction
• EventBridge: events:PutEvents

Añada destinos a su función en el diseñador de funciones de la consola de Lambda.

Para configurar un destino para registros de invocación asincrónicos

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add destination (Añadir destino).

93
 AWS Lambda Guía para desarrolladores
API de configuración de invocación asincrónica

4. En Source (Origen), elija Asynchronous invocation (Invocación asincrónica).

5. En Condition (Condición) elija una de las siguientes opciones:

• On failure (En caso de error): enviar un registro cuando el evento no supera los intentos de
procesamiento o supera la antigüedad máxima.
• On success (Si es correcto): enviar un registro cuando la función procesa correctamente una
invocación asincrónica.
6. En Destination type (Tipo de destino), elija el tipo de recurso que recibe el registro de invocación.
7. En Destination (Destino), elija un recurso.
8. Seleccione Save.

Cuando una invocación coincide con la condición, Lambda envía un documento JSON con detalles sobre
la invocación al destino. El ejemplo siguiente muestra un registro de invocación para un evento que ha
fallado tres intentos de procesamiento debido a un error de función.

Example Registro de invocación

{
"version": "1.0",
"timestamp": "2019-11-14T18:16:05.568Z",
"requestContext": {
"requestId": "e4b46cbf-b738-xmpl-8880-a18cdf61200e",
"functionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:
$LATEST",
"condition": "RetriesExhausted",
"approximateInvokeCount": 3
},
"requestPayload": {
"ORDER_IDS": [
"9e07af03-ce31-4ff3-xmpl-36dce652cb4f",
"637de236-e7b2-464e-xmpl-baf57f86bb53",
"a81ddca6-2c35-45c7-xmpl-c3a03a31ed15"
]
},
"responseContext": {
"statusCode": 200,
"executedVersion": "$LATEST",
"functionError": "Unhandled"
},
"responsePayload": {
"errorMessage": "RequestId: e4b46cbf-b738-xmpl-8880-a18cdf61200e Process exited
before completing request"
}
}

El registro de invocación contiene detalles sobre el evento, la respuesta y el motivo por el que se ha
enviado el registro.

API de configuración de invocación asincrónica

Para administrar la configuración de invocación asincrónica con la CLI o el SDK de AWS, utilice las
siguientes operaciones de la API.

• PutFunctionEventInvokeConfig
• GetFunctionEventInvokeConfig
• UpdateFunctionEventInvokeConfig

94
 AWS Lambda Guía para desarrolladores
Colas de mensajes fallidos

• ListFunctionEventInvokeConfigs
• DeleteFunctionEventInvokeConfig

Para configurar la invocación asincrónica con la CLI de AWS, utilice el comando put-function-event-
invoke-config. En el ejemplo siguiente se configura una función con una antigüedad máxima de evento
de 1 hora y sin reintentos.

$ aws lambda put-function-event-invoke-config --function-name error \

--maximum-event-age-in-seconds 3600 --maximum-retry-attempts 0
{
"LastModified": 1573686021.479,
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:error:$LATEST",
"MaximumRetryAttempts": 0,
"MaximumEventAgeInSeconds": 3600,
"DestinationConfig": {
"OnSuccess": {},
"OnFailure": {}
}
}

El comando put-function-event-invoke-config sobrescribe cualquier configuración existente en la

función, versión o alias. Para configurar una opción sin reiniciar otras, utilice update-function-event-
invoke-config. En el ejemplo siguiente se configura Lambda para enviar un registro a una cola de SQS
llamada destination cuando no se puede procesar un evento.

$ aws lambda update-function-event-invoke-config --function-name error \

--destination-config '{"OnFailure":{"Destination": "arn:aws:sqs:us-
east-2:123456789012:destination"}}'
{
"LastModified": 1573687896.493,
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:error:$LATEST",
"MaximumRetryAttempts": 0,
"MaximumEventAgeInSeconds": 3600,
"DestinationConfig": {
"OnSuccess": {},
"OnFailure": {
"Destination": "arn:aws:sqs:us-east-2:123456789012:destination"
}
}
}

Colas de mensajes fallidos de funciones de AWS

Lambda
Como alternativa a un destino en caso de fallo (p. 92), puede configurar su función con una cola
de mensajes fallidos para guardar eventos descartados para su posterior procesamiento. Una cola de
mensajes fallidos actúa igual que un destino en caso de error, ya que se utiliza cuando un evento falla
todos los intentos de procesamiento o caduca sin ser procesado. Sin embargo, una cola de mensajes
fallidos forma parte de la configuración específica de la versión de una función, por lo que se bloquea
cuando se publica una versión. Los destinos en caso de error también admiten destinos adicionales e
incluyen detalles sobre la respuesta de la función en el registro de invocación.

Si no se dispone de una cola o tema, debe crearse. Elija el tipo de destino que coincida con su caso de
uso.

• Cola de Amazon SQS: una cola que contiene eventos fallidos hasta que se recuperan. Puede recuperar
eventos manualmente o configurar Lambda para leer desde la cola (p. 277) e invocar una función.

95
 AWS Lambda Guía para desarrolladores
Colas de mensajes fallidos

En la consola de Amazon SQS, cree una cola.

• Tema de Amazon SNS: un tema transmite eventos fallidos a uno o más destinos. Puede configurar un
tema para enviar eventos a una dirección de correo electrónico, una función de Lambda o un punto de
enlace HTTP.

Cree un tema en la consola de Amazon SNS.

Para enviar eventos a una cola o tema, la función necesita permisos adicionales. Añada una política con
los permisos necesarios al rol de ejecución (p. 32) de la función.

• Amazon SQS: sqs:SendMessage

• Amazon SNS: sns:Publish

Si la cola o el tema de destino están cifrados con una clave administrada por el cliente, el rol de ejecución
también debe ser un usuario en la política basada en recursos de la clave.

Después de crear el destino y actualizar el rol de ejecución de la función, añada la cola de mensajes
fallidos a la función. Puede configurar varias funciones para enviar eventos al mismo destino.

Para configurar una cola de mensajes fallidos

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Asynchronous invocation (Invocación asincrónica), elija Edit (Editar).
4. Establezca DLQ resource (Recurso de DLQ) en Amazon SQS o Amazon SNS.
5. Elija la cola o el tema de destino.
6. Seleccione Save (Guardar).

Para configurar una cola de mensajes fallidos con la AWS CLI, utilice el comando update-function-
configuration.

$ aws lambda update-function-configuration --function-name my-function \

--dead-letter-config TargetArn=arn:aws:sns:us-east-2:123456789012:my-topic

Lambda envía el evento a la cola de mensajes fallidos tal y como está, con información adicional en
atributos. Puede utilizar esta información para identificar el error que la función devuelve o correlacionar el
evento con los registros o un rastro de AWS X-Ray.

Atributos de mensajes de cola de mensajes fallidos

• RequestID (cadena): el ID de la solicitud de invocación. Los ID de las solicitudes aparecen en los

registros de la función. También puede usar el SDK de X-Ray para registrar el ID de solicitud en un
atributo del rastro. A continuación, puede buscar rastros por ID de solicitud en la consola de X-Ray.
Consulte el ejemplo de procesador de errores (p. 141) para ver un ejemplo.
• ErrorCode (número): el código de estado de HTTP.
• ErrorMessage (cadena): el primer 1 KB del mensaje de error.

96
 AWS Lambda Guía para desarrolladores
Mapeo de orígenes de eventos

Si Lambda no puede enviar un mensaje a la cola de mensajes fallidos, elimina el evento y emite la métrica
DeadLetterErrors (p. 400). Esto puede ocurrir debido a la falta de permisos o si el tamaño total del
mensaje supera el límite de la cola o tema de destino. Por ejemplo, si una notificación de Amazon SNS
cuyo cuerpo tiene cerca de 256 KB activa una función que genera un error, los datos adicionales del
evento añadidos por Amazon SNS, junto con los atributos añadidos por Lambda, pueden hacer que el
mensaje supere el tamaño máximo permitido en la cola de mensajes fallidos.

Si está utilizando Amazon SQS como origen de eventos, configure una cola de mensajes fallidos en la
propia cola de Amazon SQS y no en la función de Lambda. Para obtener más información, consulte Uso
de AWS Lambda con Amazon SQS (p. 277).

Mapeo de origen de eventos de AWS Lambda

Un mapeo de origen de eventos es un recurso de AWS Lambda que lee desde un origen de eventos e
invoca una función de Lambda. Puede utilizar mapeos de orígenes de eventos para procesar elementos de
una transmisión o una cola en los servicios que no invocan funciones de Lambda directamente. Lambda
proporciona mapeos de orígenes de eventos de los siguientes servicios.

Servicios cuyos eventos lee Lambda

• Amazon Kinesis (p. 233)

• Amazon DynamoDB (p. 204)
• Amazon Simple Queue Service (p. 277)

Un mapeo de origen de eventos utiliza los permisos en el rol de ejecución (p. 32) de la función para leer
y administrar elementos en el origen del evento. Los permisos, la estructura de eventos, los ajustes y
el comportamiento de sondeo varían en función del origen de eventos. Para obtener más información,
consulte el tema vinculado para el servicio que puede usar como origen de eventos.

Para administrar las asignaciones de orígenes de eventos con la AWS CLI o el SDK de AWS, utilice las
siguientes acciones de la API:

97
 AWS Lambda Guía para desarrolladores
Mapeo de orígenes de eventos

• CreateEventSourceMapping (p. 460)

• ListEventSourceMappings (p. 537)
• GetEventSourceMapping (p. 496)
• UpdateEventSourceMapping (p. 592)
• DeleteEventSourceMapping (p. 477)

En el siguiente ejemplo se utiliza la AWS CLI para asignar una función llamada my-function a una
secuencia de DynamoDB especificada mediante un nombre de recurso de Amazon (ARN), con un tamaño
de lote de 500.

$ aws lambda create-event-source-mapping --function-name my-function --batch-size 500 --

starting-position LATEST \
--event-source-arn arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525
{
"UUID": "14e0db71-5d35-4eb5-b481-8945cf9d10c2",
"BatchSize": 500,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1560209851.963,
"LastProcessingResult": "No records processed",
"State": "Creating",
"StateTransitionReason": "User action",
"DestinationConfig": {},
"MaximumRecordAgeInSeconds": 604800,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 10000
}

Los mapeos de origen de eventos leen elementos de un flujo o cola en los lotes. Incluyen varios elementos
en caso de que su función los reciba. Puede configurar el tamaño del lote que el mapeo de origen de
eventos envía a su función, hasta un máximo que varía según el servicio. El número de elementos en el
evento puede ser menor que el tamaño del lote si no hay suficientes elementos disponibles o si el lote es
demasiado grande para enviarse en un evento y tiene que dividirse.

En el ejemplo siguiente se muestra una asignación de origen de eventos que lee desde una secuencia de
Kinesis. Si un lote de eventos falla todos los intentos de procesamiento, la asignación de origen de eventos
envía detalles sobre el lote a una cola de SQS.

98
 AWS Lambda Guía para desarrolladores
Mapeo de orígenes de eventos

El lote de eventos es el evento que Lambda envía a la función. Es un lote de registros o mensajes
compilados a partir de los elementos que la asignación de origen de eventos lee desde una secuencia o
cola. El tamaño del lote y otras configuraciones solo se aplican al lote de eventos.

En transmisiones, un mapeo de origen de eventos crea un iterador para cada fragmento de la transmisión
y procesa los elementos de cada fragmento en orden. Puede configurar el mapeo de origen de eventos
para nuevos elementos de solo lectura que aparecen en la transmisión, o para comenzar con los
elementos más antiguos. Los elementos procesados no se eliminan de la transmisión y se pueden
procesar a través de otras funciones o consumidores.

De forma predeterminada, si su función devuelve un error, todo el lote se procesa hasta que la función se
realice correctamente o los elementos del lote caduquen. Para garantizar el procesamiento en orden, el
procesamiento de los fragmentos afectadas se mantiene en pausa hasta que se resuelve el error. Puede
configurar la asignación de origen de eventos para descartar eventos antiguos, restringir el número de
reintentos o procesar varios lotes en paralelo. Si procesa varios lotes en paralelo, el procesamiento en

99
 AWS Lambda Guía para desarrolladores
Mapeo de orígenes de eventos

orden sigue estando garantizado para cada clave de partición, pero se procesan simultáneamente varias
claves de partición en el mismo fragmento.

También puede configurar la asignación de origen de eventos para enviar un registro de invocación a otro
servicio cuando descarta un lote de eventos. Lambda admite los siguientes destinos (p. 92) para las
asignaciones de origen de eventos.

• Amazon SQS: una cola de SQS.

• Amazon SNS: un tema de SNS.

El registro de invocación contiene detalles sobre el lote de eventos fallido en formato JSON.

El siguiente ejemplo muestra un registro de invocación para un flujo de Kinesis.

Example Registro de invocación

{
"requestContext": {
"requestId": "c9b8fa9f-5a7f-xmpl-af9c-0c604cde93a5",
"functionArn": "arn:aws:lambda:us-east-2:123456789012:function:myfunction",
"condition": "RetryAttemptsExhausted",
"approximateInvokeCount": 1
},
"responseContext": {
"statusCode": 200,
"executedVersion": "$LATEST",
"functionError": "Unhandled"
},
"version": "1.0",
"timestamp": "2019-11-14T00:38:06.021Z",
"KinesisBatchInfo": {
"shardId": "shardId-000000000001",
"startSequenceNumber": "49601189658422359378836298521827638475320189012309704722",
"endSequenceNumber": "49601189658422359378836298522902373528957594348623495186",
"approximateArrivalOfFirstRecord": "2019-11-14T00:38:04.835Z",
"approximateArrivalOfLastRecord": "2019-11-14T00:38:05.580Z",
"batchSize": 500,
"streamArn": "arn:aws:kinesis:us-east-2:123456789012:stream/mystream"
}
}

Lambda también admite el procesamiento en orden para colas FIFO (primero en entrar, primero en
salir) (p. 277), escalando hasta el número de grupos de mensajes activos. Para las colas estándar, los
elementos no se procesan necesariamente en orden. Lambda escala para procesar una cola estándar lo
más rápido posible. Cuando hay un error, los lotes se devuelven a la cola como elementos individuales y
pueden procesarse en una agrupación diferente del lote original. Ocasionalmente, el mapeo de origen de
eventos podría recibir el mismo elemento de la cola dos veces, incluso si no se ha producido un error de
función. Lambda elimina elementos de la cola una vez que se procesan correctamente. Puede configurar la
cola de origen para que envíe elementos a una cola de mensajes fallidos si no se pueden procesar.

Para obtener más información acerca de los servicios que invocan funciones de Lambda directamente,
consulte Uso de AWS Lambda con otros servicios (p. 153).

100
 AWS Lambda Guía para desarrolladores
Estados de función

Monitorización del estado de una función con la API

de Lambda
Al crear o actualizar una función, Lambda aprovisiona los recursos informáticos y de red que permiten que
se ejecute. En la mayoría de los casos, este proceso es muy rápido y su función está lista para invocarse o
modificarse de inmediato.

Si configura su función para conectarse a una nube privada virtual (VPC), el proceso puede tardar más
tiempo. Cuando conecta por primera vez una función a una VPC, Lambda aprovisiona interfaces de red,
lo que tarda aproximadamente un minuto. Para comunicar el estado actual de su función, Lambda incluye
campos adicionales en el documento de configuración de la función (p. 635) que se devuelve mediante
varias acciones de la API de Lambda.

Cuando se crea una función, inicialmente se encuentra en el estado Pending. Cuando la función
está lista para invocarse, el estado cambia de Pending a Active. Mientras el estado es Pending,
las invocaciones y otras acciones de la API que actúan en la función devuelven un error. Si crea
automatización en torno a la creación y actualización de funciones, espere a que la función se active antes
de realizar acciones adicionales que actúen en la función.

Puede utilizar la API de Lambda para obtener información sobre el estado de una función. La información
de estado se incluye en el documento FunctionConfiguration (p. 635) que devuelven varias acciones
de la API. Para ver el estado de la función con la AWS CLI, utilice el comando get-function-
configuration.

$ aws lambda get-function-configuration --function-name my-function

{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"TracingConfig": {
"Mode": "Active"
},
"State": "Pending",
"StateReason": "The function is being created.",
"StateReasonCode": "Creating",
...
}

StateReason y StateReasonCode contienen información adicional sobre el estado cuando no es

Active. Se produce un error en las siguientes operaciones mientras la creación de la función está
pendiente:

• Invoke (p. 527)

• UpdateFunctionCode (p. 598)
• UpdateFunctionConfiguration (p. 605)
• PublishVersion (p. 563)

Al actualizar la configuración de una función, la actualización puede desencadenar una operación

asincrónica para aprovisionar recursos. Mientras está en curso, puede invocar la función, pero no
se podrán realizar otras operaciones en la función. Las invocaciones que se producen mientras la
actualización está en curso se ejecutan en la configuración anterior. El estado de la función es Active,
pero LastUpdateStatus es InProgress.

101
 AWS Lambda Guía para desarrolladores
Escalado de funciones

Example Configuración de funciones: conexión a una VPC

{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"VpcConfig": {
"SubnetIds": [
"subnet-071f712345678e7c8",
"subnet-07fd123456788a036",
"subnet-0804f77612345cacf"
],
"SecurityGroupIds": [
"sg-085912345678492fb"
],
"VpcId": "vpc-08e1234569e011e83"
},
"State": "Active",
"LastUpdateStatus": "InProgress",
...
}

Se produce un error en las siguientes operaciones mientras se está realizando una actualización
asincrónica:

• UpdateFunctionCode (p. 598)

• UpdateFunctionConfiguration (p. 605)
• PublishVersion (p. 563)

Otras operaciones, incluida la invocación, funcionan mientras se realizan las actualizaciones.

Por ejemplo, cuando conecta su función a una nube privada virtual (VPC), Lambda aprovisiona una interfaz
de red elástica para cada subred. Este proceso puede dejar su función en un estado pendiente durante
un minuto más o menos. Lambda también recupera las interfaces de red que no están en uso y cambia
la su función a un estado Inactive. Cuando la función está inactiva, una invocación hace que cambie al
estado Pending mientras se restaura el acceso a la red. La invocación que desencadena la restauración y
otras invocaciones mientras la operación está pendiente, falla con ResourceNotReadyException.

Si Lambda encuentra un error al restaurar la interfaz de red de una función, la función vuelve al
estado Inactive. La siguiente invocación puede desencadenar otro intento. Para algunos errores de
configuración, Lambda espera al menos 5 minutos antes de intentar crear otra interfaz de red. Estos
errores tienen los siguientes valores LastUpdateStatusReasonCode:

• InsufficientRolePermission: El rol no existe o le faltan permisos.

• SubnetOutOfIPAddresses: Todas las direcciones IP de una subred están en uso.

Para obtener más información sobre el funcionamiento de los estados con conectividad de VPC, consulte
Configuración de una función Lambda para obtener acceso a los recursos en una VPC (p. 78).

Escalado de funciones de AWS Lambda

La primera vez que invoque la función, AWS Lambda crea una instancia de la función y ejecuta su método
del controlador para procesar el evento. Cuando la función devuelve una respuesta, permanece activa y
espera para procesar eventos adicionales. Si vuelve a invocar la función mientras se procesa el primer

102
 AWS Lambda Guía para desarrolladores
Escalado de funciones

evento, Lambda inicializa otra instancia y la función procesa los dos eventos simultáneamente. Conforme
entran más eventos, Lambda los dirige a instancias disponibles y crea nuevas instancias según sea
necesario. Cuando el número de solicitudes disminuye, Lambda detiene las instancias no utilizadas para
liberar capacidad de escalado para otras funciones.

La simultaneidad de las funciones es el número de instancias que atienden solicitudes en un momento

dado. En una ráfaga inicial de tráfico, la simultaneidad total de la función en una Región puede alcanzar un
nivel inicial de entre 500 y 3000, que varía por región.

Límites ráfaga de simultaneidad

• 3000: [Link]. Oeste (Oregón), US East (N. Virginia), Europa (Irlanda).

• 1000: Asia Pacífico (Tokio), Europa (Fráncfort)
• 500: Otras regiones

Después de la ráfaga inicial, la simultaneidad de la función puede escalarse en 500 instancias adicionales
cada minuto. Esto continúa hasta que haya suficientes instancias para servir a todas las solicitudes o hasta
que se alcance un límite de simultaneidad. Cuando llegan las solicitudes más rápidamente de lo que la
función puede escalar o cuando la función está en simultaneidad máxima, las solicitudes adicionales fallan
con un error de limitación (código de estado 429).

El siguiente ejemplo muestra una función que procesa un pico de tráfico. A medida que las invocaciones
aumentan exponencialmente, la función se escala hacia arriba. Inicializa una nueva instancia para
cualquier solicitud que no se pueda enrutar a una instancia disponible. Cuando se alcanza el límite de
ráfaga de simultaneidad, la función comienza a escalar linealmente. Si no es suficiente simultaneidad para
atender todas las solicitudes, las solicitudes adicionales se limitarán y se deben volver a intentar.

103
 AWS Lambda Guía para desarrolladores
Escalado de funciones

Leyenda

• Instancias de función
• Solicitudes abiertas
• Posibles limitaciones

La función continúa escalando hasta que se alcanza el límite de simultaneidad de la cuenta para la Región
de la función. La función alcanza la demanda, las solicitudes disminuyen y las instancias no utilizadas de
la función se detienen después de estar inactivas durante algún tiempo. Las instancias no utilizadas se
congelan mientras esperan solicitudes y no generan cargos.

104
 AWS Lambda Guía para desarrolladores
Escalado de funciones

El límite de concurrencia regional comienza en 1,000. Puede aumentar el límite enviando una solicitud
en la consola del Centro de soporte técnico. Para asignar capacidad por función, puede configurar las
funciones con simultaneidad reservada (p. 59). La simultaneidad reservada crea un grupo que solo su
función puede utilizar y también evita que su función use simultaneidad sin reservas.

Cuando su función escala hacia arriba, la primera solicitud atendida por cada instancia se ve afectada
por el tiempo que tarda en cargar e inicializar su código. Si el código de inicialización (p. 19) tarda mucho
tiempo, el impacto en la latencia media y percentil puede ser significativo. Para que su función pueda
escalar sin fluctuaciones en la latencia, utilice la simultaneidad aprovisionada (p. 59). En el ejemplo
siguiente se muestra una función con simultaneidad aprovisionada que procesa un pico de tráfico.

Leyenda

• Instancias de función
• Solicitudes abiertas
• Simultaneidad aprovisionada
• Simultaneidad estándar

105
 AWS Lambda Guía para desarrolladores
Escalado de funciones

Cuando se asigna la simultaneidad aprovisionada, la función se escala con el mismo comportamiento

de ráfaga que la simultaneidad estándar. Una vez asignada, la simultaneidad aprovisionada atiende
las solicitudes entrantes con una latencia muy baja. Cuando se está utilizando toda la simultaneidad
aprovisionada, la función se amplía normalmente para gestionar cualquier solicitud adicional.

Auto Scaling de aplicaciones lleva esto un paso más allá al proporcionar escalado automático
para la simultaneidad aprovisionada. Con Auto Scaling de aplicaciones, puede crear una política
de escala de seguimiento de destino que ajuste automáticamente los niveles de simultaneidad
aprovisionados, en función de la métrica de utilización que Lambda emita. Utilice la API de Auto Scaling de
aplicaciones (p. 65) para registrar un alias como destino escalable y crear una política de escalado.

En el siguiente ejemplo, una función escala entre cantidades mínimas y máximas de simultaneidad
aprovisionada basada en su uso. Cuando el número de solicitudes abiertas aumenta, Auto Scaling
de aplicaciones aumenta la simultaneidad aprovisionada a pasos grandes hasta que llega al máximo
configurado. La función sigue escalando en simultaneidad estándar hasta que su uso comienza a
disminuir. Cuando el uso es consistentemente bajo, Auto Scaling de aplicaciones reduce la simultaneidad
aprovisionada en pasos periódicos más pequeños.

106
 AWS Lambda Guía para desarrolladores
Control de errores

Leyenda

• Instancias de función
• Solicitudes abiertas
• Simultaneidad aprovisionada
• Simultaneidad estándar

Al invocar la función de forma asíncrona mediante un mapeo de origen de eventos u otro servicio de AWS,
el comportamiento de escalado varía. Por ejemplo, los mapeos de orígenes de eventos que leen a partir
de una transmisión están limitados por la cantidad de fragmentos de la transmisión. La capacidad de
ampliación que no está utilizada por un origen de eventos está disponible para su uso por parte de otros
clientes y orígenes de eventos. Para obtener más información, consulte los siguientes temas.

• Invocación asíncrona (p. 89)

• Mapeo de origen de eventos de AWS Lambda (p. 97)
• Control de errores y reintentos automáticos en AWS Lambda (p. 107)
• Uso de AWS Lambda con otros servicios (p. 153)

Puede monitorizar los niveles de simultaneidad de su cuenta mediante las métricas siguientes:

Métricas de simultaneidad

• ConcurrentExecutions
• UnreservedConcurrentExecutions
• ProvisionedConcurrentExecutions
• ProvisionedConcurrencyInvocations
• ProvisionedConcurrencySpilloverInvocations
• ProvisionedConcurrencyUtilization

Para obtener más información, consulte Trabajar con métricas de función de AWS Lambda (p. 400).

Control de errores y reintentos automáticos en AWS

Lambda
Al invocar una función, se producen dos tipos de error. Se producen errores de invocación cuando se
rechaza la solicitud de invocación antes de que su función la reciba. Los errores de función se producen
cuando el código de la función o el tiempo de ejecución (p. 118) devuelve un error. En función del tipo
de error, el tipo de invocación y el cliente o servicio que invoca la función, varía el comportamiento de
reintentos y la estrategia para gestionar los errores.

Problemas con la solicitud, el intermediario o la cuenta pueden provocar errores de invocación. Los errores
de invocación incluyen un tipo de error y un código de estado en la respuesta que indican la causa del
error.

Errores de invocación comunes

• Request (Solicitud): el evento de solicitud es demasiado grande o no es un JSON válido, la función no

existe o el valor de un parámetro es de un tipo erróneo.
• Caller (Intermediario): el usuario o servicio no tiene permiso para invocar la función.

107
 AWS Lambda Guía para desarrolladores
Control de errores

• Account (Cuenta): el número máximo de instancias de función ya se están ejecutando o se realizan

solicitudes con demasiada rapidez.

Los clientes como la AWS CLI y el SDK de AWS reintentan si se supera el tiempo de espera de cliente,
hay errores de limitación controlada (429) y otros errores no causados por una solicitud incorrecta (serie
500). Para obtener una lista completa de los errores de invocación, consulte Invoke (p. 527).

Los errores de función se producen cuando el código de la función o el tiempo de ejecución que utiliza
devuelve un error.

Errores de funciones comunes

• Function (Función): su código de la función genera una excepción o devuelve un objeto de error.
• Runtime (Tiempo de ejecución): el tiempo de ejecución terminó la función al agotarse el tiempo de
espera, al detectarse un error de sintaxis o al no haber podido serializar el objeto de respuesta en JSON.
La función salió con un código de error.

A diferencia de los errores de invocación, los errores de funciones no hacen que Lambda devuelva un
código de estado de la serie 400 o de la serie 500. Si la función devuelve un error, Lambda lo indica
incluyendo un encabezado con el nombre X-Amz-Function-Error, y una respuesta con formato JSON
con el mensaje de error y otros detalles. Para ver ejemplos de errores de las funciones en cada idioma,
consulte los siguientes temas.

• Errores de funciones AWS Lambda en [Link] (p. 299)

• Errores de funciones AWS Lambda en Python (p. 313)
• Errores de funciones de AWS Lambda en Ruby (p. 326)
• Errores de funciones AWS Lambda en Java (p. 347)
• AWS Lambda Errores de funciones en Go (p. 369)
• AWS Lambda Errores de funciones en C# (p. 387)
• AWS Lambda errores de función en PoweShell. (p. 397)

Al invocar una función directamente, se determina la estrategia para la gestión del seguimiento de errores.
Puede volver a probar, enviar el evento a una cola para su depurar o ignorar el error. El código de la
función puede haberse ejecutado en su totalidad, en parte o no haberse ejecutado. Si vuelve a intentarlo,
asegúrese de que el código de la función pueda gestionar el mismo evento varias veces sin generar
transacciones duplicados u otros efectos colaterales no deseados.

Al invocar una función indirectamente, que debe tener en cuenta el comportamiento de reintento del
invocador y cualquier servicio que la solicitud encuentra en el proceso. Esto incluye los siguientes
escenarios.

• Asynchronous Invocation (Invocación asíncrona): Lambda reintenta los errores de funciones dos veces.
Si la función no tiene capacidad suficiente para gestionar todas las solicitudes entrantes, los eventos
podrían esperan en la cola durante horas o días para su envío a la función. Puede configurar una cola
de mensajes fallidos en la función para capturar eventos que no se hubieran procesado correctamente.
Para obtener más información, consulte Invocación asíncrona (p. 89).
• Event Source Mappings (mapeos de origen de eventos): los mapeos de orígenes de eventos que
leen desde transmisiones reintentan el lote de elementos completo. Los errores repetidos bloquean el
procesamiento del fragmento afectado hasta que se resuelve el error o los elementos caduquen. Para
detectar fragmentos estancados, puede monitorizar la métrica antigüedad del iterador (p. 400).

Para mapeos de orígenes de eventos que leen de una cola, debe determinar el período de tiempo entre
los reintentos y el destino de los eventos fallidos configurando el tiempo de espera de visibilidad y la
política de redireccionamiento en la cola de origen. Para obtener más información, consulte Mapeo

108
 AWS Lambda Guía para desarrolladores
SDK de Mobile para Android

de origen de eventos de AWS Lambda (p. 97) y los temas específicos del servicio en Uso de AWS
Lambda con otros servicios (p. 153).
• AWS Services (Servicios de AWS ): los servicios de AWS pueden invocar la función de forma
síncrona (p. 88) o asíncrona. Para la invocación síncrona, el servicio decide si volver a intentarlo.
Servicios como API Gateway y Elastic Load Balancing, que el proxy solicita de un usuario o cliente
ascendente, también pueden optar por retransmitir la respuesta de error al solicitante.

Para invocación asíncrona, el comportamiento es el mismo que cuando se invoca la función de

forma asíncrona. Para obtener más información, consulte los temas específicos de servicios en la
documentación de Uso de AWS Lambda con otros servicios (p. 153) y el servicio de invocación.
• Other Accounts and Clients (Otras cuentas y clientes): al conceder acceso a otras cuentas, puede utilizar
políticas basadas en recursos (p. 36) para restringir los servicios o recursos que pueden configurar para
invocar la función. Para proteger su función de sobrecargas, considere la posibilidad de colocar una
capa de API delante de su función con Amazon API Gateway (p. 157).

Para ayudarle a abordar errores en aplicaciones de Lambda, Lambda se integra con servicios como
Amazon CloudWatch y AWS X-Ray. Puede utilizar una combinación de registros, métricas, alarmas y
seguimiento para detectar y identificar rápidamente problemas en el código de la función, la API u otros
recursos que admiten la aplicación. Para obtener más información, consulte Monitorización y solución de
problemas de aplicaciones basadas en Lambda (p. 399).

Para una aplicación de muestra que utiliza una suscripción de CloudWatch Logs, seguimiento de X-Ray y
una función de Lambda para detectar y procesar errores, consulte Aplicación de ejemplo de procesamiento
de errores para AWS Lambda (p. 141).

Invocación de funciones de Lambda con el SDK de

AWS Mobile para Android
Puede llamar a una función de Lambda desde una aplicación móvil. Ponga la lógica de negocio en
funciones para separar su ciclo de vida de desarrollo del de los clientes de front-end, lo que hace
que el desarrollo y el mantenimiento de las aplicaciones móviles resulte menos complicado. Con el
SDK de Mobile para Android, se utiliza Amazon Cognito para autenticar a los usuarios y autorizar las
solicitudes (p. 110).

Al invocar una función desde una aplicación móvil, puede seleccionar la estructura del evento, el tipo de
invocación (p. 87) y el modelo de permisos. Puede utilizar los alias (p. 70) para permitir actualizaciones
sin problemas del código de la función, pero por lo demás, la función y la aplicación están estrechamente
vinculadas. A medida que añada más funciones, puede crear una capa de API para desacoplar el código
de las funciones de los clientes de front-end y mejorar el rendimiento.

Para crear una API web completa para las aplicaciones móviles y web, utilice Amazon API Gateway. Con
API Gateway, puede añadir autorizadores personalizados, limitar las solicitudes y almacenar los resultados
en caché para todas sus funciones. Para obtener más información, consulte Uso de AWS Lambda con
Amazon API Gateway (p. 157).

Temas
• Tutorial: Uso de AWS Lambda con el SDK de Mobile para Android (p. 110)
• Código de función de muestra (p. 115)

109
 AWS Lambda Guía para desarrolladores
Tutorial

Tutorial: Uso de AWS Lambda con el SDK de Mobile

para Android
En este tutorial, se crea una aplicación móvil sencilla para Android que utiliza Amazon Cognito para
obtener las credenciales e invoca una función de Lambda.

La aplicación móvil recupera las credenciales de AWS de un grupo de identidades de Amazon Cognito
y las utiliza para invocar una función de Lambda con un evento que contiene los datos de la solicitud. La
función procesa la solicitud y devuelve una respuesta al front-end.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

110
 AWS Lambda Guía para desarrolladores
Tutorial

2. Elija Create role (Crear rol).

3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – AWS Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-android-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Creación de la función
El siguiente ejemplo utiliza datos para generar una respuesta de cadena.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 115).

Example [Link]

[Link] = function(event, context, callback) {

[Link]("Received event: ", event);
var data = {
"greetings": "Hello, " + [Link] + " " + [Link] + "."
};
callback(null, data);
}

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name AndroidBackendLambdaFunction \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-android-role

Pruebe la función Lambda.

Invoque la función de forma manual utilizando los datos del evento de muestra.

Para probar la función de Lambda (AWS CLI)

1. Guarde el siguiente evento de muestra JSON en un archivo, [Link].

{ "firstName": "first-name", "lastName": "last-name" }

2. Ejecute el siguiente comando invoke:

$ aws lambda invoke --function-name AndroidBackendLambdaFunction \

111
 AWS Lambda Guía para desarrolladores
Tutorial

--payload [Link] [Link]

Creación de un grupo de identidades Amazon Cognito.

En esta sección, va a crear un grupo de identidades de Amazon Cognito. El grupo de identidades tiene dos
roles de IAM. Puede actualizar el rol de IAM para usuarios sin autenticar y otorgar permisos para ejecutar
la función AndroidBackendLambdaFunction de Lambda.

Para obtener más información sobre los roles de IAM, consulte Roles de IAM en la Guía del usuario de
IAM. Para obtener más información acerca de los servicios de Amazon Cognito, consulte la página de
detalles del producto de Amazon Cognito.

Para crear un grupo de identidades

1. Abra la consola de Amazon Cognito.

2. Cree un nuevo grupo de identidades denominado JavaFunctionAndroidEventHandlerPool.
Antes de seguir el procedimiento para crear un grupo de identidades, tenga en cuenta lo siguiente:

• El grupo de identidades que está creando debe permitir el acceso a identidades sin autenticar
porque la aplicación móvil de ejemplo no requiere que el usuario inicie sesión. Por lo tanto,
asegúrese de seleccionar la opción Enable access to unauthenticated identities (Habilitar acceso a
identidades sin autenticar).
• Añada la siguiente instrucción a la política de permisos asociada con las identidades sin autenticar.

{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction"
],
"Resource": [
"arn:aws:lambda:us-
east-1:123456789012:function:AndroidBackendLambdaFunction"
]
}

La política resultante será la siguiente:

{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"mobileanalytics:PutEvents",
"cognito-sync:*"
],
"Resource":[
"*"
]
},
{
"Effect":"Allow",
"Action":[
"lambda:invokefunction"
],
"Resource":[
"arn:aws:lambda:us-east-1:account-
id:function:AndroidBackendLambdaFunction"
]

112
 AWS Lambda Guía para desarrolladores
Tutorial

}
]
}

Para obtener instrucciones acerca de cómo crear un grupo de identidades, inicie sesión en la consola
de Amazon Cognito y siga el asistente New Identity Pool (Nuevo grupo de identidades).
3. Anote el ID del grupo de identidades. Debe especificar este ID en la aplicación móvil que creará en
la siguiente sección. La aplicación utiliza este ID cuando envía una solicitud a Amazon Cognito para
solicitar credenciales de seguridad temporales.

Cree una aplicación Android

Cree una aplicación móvil sencilla para Android que genera eventos e invoca funciones de Lambda
pasando los datos de eventos como parámetros.

Las siguientes instrucciones se han verificado utilizando Android studio.

1. Cree un nuevo proyecto de Android denominado AndroidEventGenerator utilizando la siguiente

configuración:

• Seleccione la plataforma Phone and Tablet.

• Elija Blank Activity.
2. En el archivo [Link] (Module:app), añada lo siguiente en la sección dependencies:

compile '[Link]:aws-android-sdk-core:2.2.+'
compile '[Link]:aws-android-sdk-lambda:2.2.+'

3. Compile el proyecto para que las dependencias necesarias se descarguen según sea necesario.
4. En el manifiesto de la aplicación para Android ([Link]), añada los siguientes
permisos para que la aplicación se pueda conectarse a Internet. Puede añadirlos justo antes de la
etiqueta final </manifest>.

<uses-permission android:name="[Link]" />

<uses-permission android:name="[Link].ACCESS_NETWORK_STATE" />

5. En MainActivity, añada las siguientes importaciones:

import [Link].*;
import [Link];
import [Link];

6. En la sección package, añada las dos clases siguientes (RequestClass y ResponseClass). Tenga
en cuenta que el POJO es el mismo que el POJO que creó en la función de Lambda de la sección
anterior.

• RequestClass. Las instancias de esta clase actúan como POJO (Plain Old Java Object) para
datos de eventos que constan de nombre y apellidos. Si está utilizando el ejemplo de Java para la
función de Lambda que creó en la sección anterior, este POJO es igual que el POJO que creó en el
código de la función de Lambda.

package [Link]....lambdaeventgenerator;
public class RequestClass {
String firstName;
String lastName;

113
 AWS Lambda Guía para desarrolladores
Tutorial

public String getFirstName() {

return firstName;
}

public void setFirstName(String firstName) {

[Link] = firstName;
}

public String getLastName() {

return lastName;
}

public void setLastName(String lastName) {

[Link] = lastName;
}

public RequestClass(String firstName, String lastName) {

[Link] = firstName;
[Link] = lastName;
}

public RequestClass() {
}
}

• ResponseClass

package [Link]....lambdaeventgenerator;
public class ResponseClass {
String greetings;

public String getGreetings() {

return greetings;
}

public void setGreetings(String greetings) {

[Link] = greetings;
}

public ResponseClass(String greetings) {

[Link] = greetings;
}

public ResponseClass() {
}
}

7. En el mismo paquete, cree una interfaz denominada MyInterface para invocar la función de
Lambda AndroidBackendLambdaFunction.

package [Link].....lambdaeventgenerator;
import [Link];
public interface MyInterface {

/**
* Invoke the Lambda function "AndroidBackendLambdaFunction".
* The function name is the method name.
*/
@LambdaFunction
ResponseClass AndroidBackendLambdaFunction(RequestClass request);

114
 AWS Lambda Guía para desarrolladores
Código de muestra

La anotación @LambdaFunction en el código mapea el método de cliente específico a la función de

Lambda del mismo nombre.
8. Para no complicar la aplicación, vamos a añadir código para invocar la función de Lambda en el
controlador de eventos onCreate(). En MainActivity, añada el siguiente código hacia el final del
código onCreate().

// Create an instance of CognitoCachingCredentialsProvider

CognitoCachingCredentialsProvider cognitoProvider = new
CognitoCachingCredentialsProvider(
[Link](), "identity-pool-id", Regions.US_WEST_2);

// Create LambdaInvokerFactory, to be used to instantiate the Lambda proxy.

LambdaInvokerFactory factory = new LambdaInvokerFactory([Link](),
Regions.US_WEST_2, cognitoProvider);

// Create the Lambda proxy object with a default Json data binder.
// You can provide your own data binder by implementing
// LambdaDataBinder.
final MyInterface myInterface = [Link]([Link]);

RequestClass request = new RequestClass("John", "Doe");

// The Lambda function invocation results in a network call.
// Make sure it is not called from the main thread.
new AsyncTask<RequestClass, Void, ResponseClass>() {
@Override
protected ResponseClass doInBackground(RequestClass... params) {
// invoke "echo" method. In case it fails, it will throw a
// LambdaFunctionException.
try {
return [Link](params[0]);
} catch (LambdaFunctionException lfe) {
Log.e("Tag", "Failed to invoke echo", lfe);
return null;
}
}

@Override
protected void onPostExecute(ResponseClass result) {
if (result == null) {
return;
}

// Do a toast
[Link]([Link], [Link](),
Toast.LENGTH_LONG).show();
}
}.execute(request);

9. Ejecute el código y verifíquelo como se indica a continuación:

• [Link]() muestra la respuesta devuelta.

• Verifique que CloudWatch Logs muestra el registro creado por la función de Lambda. Debería
mostrar los datos del evento (nombre y apellidos). También puede verificar esto en la consola de
AWS Lambda.

Código de función de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas

115
 AWS Lambda Guía para desarrolladores
Código de muestra

• [Link] (p. 116)

• Java (p. 116)

[Link]
El siguiente ejemplo utiliza datos para generar una respuesta de cadena.

Example [Link]

[Link] = function(event, context, callback) {

[Link]("Received event: ", event);
var data = {
"greetings": "Hello, " + [Link] + " " + [Link] + "."
};
callback(null, data);
}

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

Java
El siguiente ejemplo utiliza datos para generar una respuesta de cadena.

En el código, el handler (myHandler) utiliza los tipos RequestClass y ResponseClass para entrada y
salida. El código proporciona implementación para estos tipos.

Example [Link]

package example;

import [Link];

public class HelloPojo {

// Define two classes/POJOs for use with Lambda function.

public static class RequestClass {
String firstName;
String lastName;

public String getFirstName() {

return firstName;
}

public void setFirstName(String firstName) {

[Link] = firstName;
}

public String getLastName() {

return lastName;
}

public void setLastName(String lastName) {

[Link] = lastName;
}

public RequestClass(String firstName, String lastName) {

[Link] = firstName;
[Link] = lastName;
}

116
 AWS Lambda Guía para desarrolladores
Código de muestra

public RequestClass() {
}
}

public static class ResponseClass {

String greetings;

public String getGreetings() {

return greetings;
}

public void setGreetings(String greetings) {

[Link] = greetings;
}

public ResponseClass(String greetings) {

[Link] = greetings;
}

public ResponseClass() {
}

public static ResponseClass myHandler(RequestClass request, Context context){

String greetingString = [Link]("Hello %s, %s.", [Link],
[Link]);
[Link]().log(greetingString);
return new ResponseClass(greetingString);
}
}

Dependencias.

• aws-lambda-java-core

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

117
 AWS Lambda Guía para desarrolladores

Tiempos de ejecución de AWS

Lambda.
AWS Lambda admite múltiples idiomas a través del uso de tiempos de ejecución. Usted elige un tiempo de
ejecución cuando crea una función y puede cambiar los tiempos de ejecución actualizando la configuración
de su función. El entorno de ejecución subyacente ofrece variables de entorno (p. 54) y bibliotecas
adicionales a las que puede acceder desde el código de función.

Amazon Linux

• Imagen: amzn-ami-hvm-2018.03.0.20181129-x86_64-gp2
• Kernel de Linux – 4.14.154-99.181.amzn1.x86_64

Amazon Linux 2

• Imagen: personalizada
• Kernel de Linux – 4.14.138-99.102.amzn2.x86_64

Cuando se invoca su función, Lambda intenta reutilizar el entorno de ejecución de una invocación previa,
si la hay. Esto ahorra tiempo de preparación del entorno de ejecución y le permite ahorrar recursos como
conexiones de base de datos y archivos temporales en el contexto de ejecución (p. 120) para evitar tener
que crearlos cada vez que se ejecuta la función.

Un tiempo de ejecución es compatible con una sola versión de un idioma, múltiples versiones de un idioma
o múltiples idiomas. Los tiempos de ejecución específicos de un idioma o versión de marco de trabajo
están restringidas (p. 120) cuando la versión alcanza el fin de su vida útil.

Tiempos de ejecución de [Link]

Nombre Identifier AWS SDK para Sistema operativo

JavaScript

[Link] 12 nodejs12.x 2.585.0 Amazon Linux 2

[Link] nodejs10.x 2.585.0 Amazon Linux 2

Tiempos de ejecución de Python

Nombre Identifier AWS SDK para Python Sistema operativo

Python 3.8 python3.8 boto3-1.10.34 Amazon Linux 2

botocore-1.13.34

Python 3.7 python3.7 boto3-1.10.34 Amazon Linux

botocore-1.13.34

Python 3.6 python3.6 boto3-1.10.34 Amazon Linux

botocore-1.13.34

118
 AWS Lambda Guía para desarrolladores

Nombre Identifier AWS SDK para Python Sistema operativo

Python 2.7 python2.7 boto3-1.10.34 Amazon Linux

botocore-1.13.34

Runtimes de Ruby

Nombre Identificador AWS SDK para Ruby Sistema operativo

Ruby 2.7 ruby2.7 3.0.1 Amazon Linux 2

Ruby 2.5 ruby2.5 3.0.1 Amazon Linux

Runtimes de Java

Nombre Identificador JDK Sistema operativo

Java 11 java11 amazon-corretto-11 Amazon Linux 2

Java 8 java8 java-1.8.0-openjdk Amazon Linux

Runtimes de Go

Nombre Identificador Sistema operativo

Go 1.x go1.x Amazon Linux

Runtimes de .NET

Nombre Identificador Lenguajes Sistema operativo

.NET Core 2.1 dotnetcore2.1 C# Amazon Linux

Powershell Core 6.0

Para utilizar otros lenguajes en Lambda, puede implementar un tiempo de ejecución

personalizado (p. 121). El entorno de ejecución de Lambda proporciona una interfaz de tiempo de
ejecución (p. 124) para obtener eventos de invocación y enviar respuestas. Puede implementar un
tiempo de ejecución personalizado junto con su código de función, o en una capa (p. 74).

Tiempo de ejecución personalizado

Nombre Identificador Sistema operativo

Tiempo de ejecución provided Amazon Linux

personalizado

Temas
• Contexto de ejecución de AWS Lambda. (p. 120)
• Política de soporte del tiempo de ejecución (p. 120)
• Tiempos de ejecución personalizados de AWS Lambda (p. 121)
• Interfaz de tiempo de ejecución de AWS Lambda (p. 124)

119
 AWS Lambda Guía para desarrolladores
Contexto de ejecución

• Tutorial: Publicación de un tiempo de ejecución personalizado (p. 126)

Contexto de ejecución de AWS Lambda.

Cuando AWS Lambda ejecuta una función de Lambda, se encarga de aprovisionar y administrar los
recursos necesarios para la función de Lambda. Al crear una función de Lambda, se debe especificar
información de configuración, como la cantidad de memoria y el tiempo máximo de ejecución asignados
a la función de Lambda. Al invocar una función de Lambda, AWS Lambda lanza un contexto de ejecución
basado en las opciones de configuración que proporcione. El contexto de ejecución es un entorno de
tiempo de ejecución temporal que inicializa las dependencias externas del código de su función de
Lambda, como las conexiones de bases de datos o los puntos de enlace HTTP. Esto permite un mejor
rendimiento de las invocaciones posteriores, ya que no es necesario realizar un "arranque en frío" o
inicializar estas dependencias externas, como se explica a continuación.

Se necesita tiempo para configurar un contexto de ejecución y realizar el proceso de arranque necesario,
lo que añade cierta latencia cada vez que se invoca una función de Lambda. Normalmente, esta latencia
aparece cuando se invoca una función de Lambda por primera vez o después de actualizarla, ya que
AWS Lambda intenta reutilizar el contexto de ejecución para las invocaciones posteriores de la función de
Lambda.

Una vez ejecutada la función de Lambda, AWS Lambda mantiene el contexto de ejecución durante cierto
tiempo, anticipándose a otra posible invocación de la función de Lambda. A efectos prácticos, el servicio
congela el contexto de ejecución una vez finalizada la función de Lambda y, si AWS Lambda decide
reutilizarlo cuando se invoque de nuevo la función de Lambda, lo descongela para su reutilización. Este
enfoque de reutilización de contextos de ejecución tiene las siguientes implicaciones:

• Los objetos declarados fuera del método del controlador de la función permanecen inicializados, lo que
proporciona una optimización adicional cuando la función se invoca de nuevo. Por ejemplo, si la función
de Lambda establece una conexión con una base de datos, en lugar de volver a establecer la conexión,
se utiliza la conexión original en posteriores invocaciones. Le sugerimos que añada lógica al código que
compruebe si existe una conexión antes de crear una nueva.
• Cada contexto de ejecución proporciona 512 MB de espacio en disco adicional en el directorio /tmp.
El contenido del directorio se conserva al congelar el contexto de ejecución, proporcionando una
caché transitoria que se puede utilizar para varias invocaciones. Puede agregar código adicional para
comprobar si la caché dispone de los datos que se almacenaron. Para obtener información acerca de los
límites de implementación, consulte Límites de AWS Lambda (p. 30).
• Los procesos en segundo plano o las devoluciones de llamada iniciadas por la función de Lambda que
no se completaron al finalizar la función se reanudan si AWS Lambda decide reutilizar el contexto de
ejecución. Asegúrese de que los procesos en segundo plano o las devoluciones de llamada del código
se completen antes de que este finalice.

Cuando escriba el código de la función de Lambda no presuponga que AWS Lambda reutiliza
automáticamente el contexto de ejecución para las siguientes invocaciones de la función. Otros factores
pueden dictar la necesidad de que AWS Lambda cree un nuevo contexto de ejecución, lo que puede
producir resultados inesperados, como errores de conexión a la base de datos.

Política de soporte del tiempo de ejecución

Los runtimes de AWS Lambda (p. 118) se han creado a partir de una combinación de sistema operativo,
lenguaje de programación y bibliotecas de software, todos ellos sujetos a operaciones de mantenimiento
y actualizaciones de seguridad. Cuando un componente de un tiempo de ejecución deja de recibir
actualizaciones de seguridad, Lambda descarta el tiempo de ejecución.

120
 AWS Lambda Guía para desarrolladores
Tiempos de ejecución personalizados

Este proceso se produce en dos fases. Durante la primera fase, no es posible crear funciones que utilicen
el tiempo de ejecución obsoleto. Durante al menos 30 días, puede continuar actualizando las funciones
existentes que utilizan el tiempo de ejecución obsoleto. Pasado este tiempo, tanto la creación de funciones
como sus actualizaciones se deshabilitan de forma permanente. Sin embargo, la función sigue estando
disponible para procesar eventos de invocación.
Note

Python 2.7 alcanzó el final de su vida útil el 1 de enero de 2020. Sin embargo, el tiempo de
ejecución de Python 2.7 sigue siendo compatible y no está programado para ser obsoleto en este
momento. Para obtener más información, consulte Soporte continuo para Python 2.7 en AWS
Lambda.

En la mayoría de los casos, la fecha de fin de vida útil de una versión de un lenguaje o un sistema
operativo se conoce con mucha antelación. Si tiene funciones que utilizan un tiempo de ejecución que
quedará obsoleto en los próximos 60 días, Lambda de notifica por correo electrónico que debe preparar
la migración de la función a un tiempo de ejecución admitido. En algunos casos, como, por ejemplo,
problemas de seguridad que requieren una actualización incompatible con versiones anteriores, o software
que no admite un programa de soporte a largo plazo (LTS), puede que no sea posible dar un aviso con
antelación.

Políticas de soporte de lenguajes y marcos

• [Link] – [Link]
• Python – [Link]
• Ruby – [Link]
• Java – [Link] y [Link]/corretto
• Go – [Link]
• .NET Core – [Link]

Después de que un tiempo de ejecución se quede obsoleto, es posible que Lambda lo retire por completo
en cualquier momento desactivando la invocación. Los tiempos de ejecución obsoletos no pueden recibir
actualizaciones de seguridad ni soporte técnico. Antes de retirar un tiempo de ejecución, Lambda envía
notificaciones adicionales a los clientes afectados. En este momento, no hay tiempos de ejecución que
vayan a retirarse.

Tiempos de ejecución personalizados de AWS

Lambda
Puede implementar tiempos de ejecución de AWS Lambda con cualquier lenguaje de programación. El
tiempo de ejecución es un programa que ejecuta un método de controlador de función de Lambda cuando
se invoca la función. Puede incluir un tiempo de ejecución en el paquete de implementación de su función
como un archivo ejecutable llamado bootstrap.

El tiempo de ejecución es responsable de ejecutar el código de configuración de la función, leer el nombre

del controlador a partir de una variable de entorno y leer los eventos de invocación desde la API de tiempo
de ejecución de Lambda. El tiempo de ejecución transfiere los datos de los eventos al controlador de la
función y publica la respuesta desde el controlador de vuelta a Lambda.

Su tiempo de ejecución personalizado se ejecuta en el entorno de ejecución (p. 118) estándar de

Lambda. Puede ser un script de shell, un script en un lenguaje incluido en Amazon Linux, o un archivo
ejecutable binario compilado en Amazon Linux.

121
 AWS Lambda Guía para desarrolladores
Uso de un tiempo de ejecución personalizado

Para comenzar a utilizar tiempos de ejecución personalizados, consulte Tutorial: Publicación de un tiempo
de ejecución personalizado (p. 126). También puede estudiar un tiempo de ejecución personalizado
implementado en C++ en awslabs/aws-lambda-cpp en GitHub.

Temas
• Uso de un tiempo de ejecución personalizado (p. 122)
• Creación de un tiempo de ejecución personalizado (p. 122)

Uso de un tiempo de ejecución personalizado

Para utilizar un tiempo de ejecución personalizado, establezca el tiempo de ejecución de la función en
provided. El tiempo de ejecución se puede incluir en el paquete de implementación de la función o en
una capa (p. 74).

Example [Link]

.
### bootstrap
### [Link]

Si hay un archivo llamado bootstrap en el paquete de implementación, Lambda ejecuta ese archivo. De
lo contrario, Lambda busca un tiempo de ejecución en el capas de la función. Si el no se encuentra archivo
de arranque o no es ejecutable, la función devuelve un error tras la invocación.

Creación de un tiempo de ejecución personalizado

El punto de entrada de un tiempo de ejecución personalizado es un archivo ejecutable llamado
bootstrap. El archivo de arranque puede ser el tiempo de ejecución o puede invocar otro archivo que
cree el tiempo de ejecución. En el siguiente ejemplo se utiliza una versión agrupada de [Link] para
ejecutar un tiempo de ejecución de JavaScript en un archivo aparte llamado [Link].

Example arranque

#!/bin/sh
cd $LAMBDA_TASK_ROOT
./node-v11.1.0-linux-x64/bin/node [Link]

Su código de tiempo de ejecución se encarga de completar algunas tareas de inicialización. Después

procesa eventos de invocación en bucle hasta que se finaliza. Las tareas de inicialización se ejecutan una
vez por instancia de la función (p. 120) para preparar el entorno para gestionar invocaciones.

Tareas de inicialización

• Recuperar opciones de configuración–: leer variables de entorno para obtener detalles acerca de la
función y el entorno.
• _HANDLER–: la ubicación del controlador, a partir de la configuración de la función. El formato estándar
es [Link], donde file es el nombre del archivo sin extensión, y method es el nombre de un
método o una función que se define en el archivo.
• LAMBDA_TASK_ROOT–: el directorio que contiene el código de la función.
• AWS_LAMBDA_RUNTIME_API–: el host y el puerto de la API de tiempo de ejecución.

Consulte en Variables de entorno de tiempo de ejecución (p. 56) la lista completa de variables
disponibles.

122
 AWS Lambda Guía para desarrolladores
Creación de un tiempo de ejecución personalizado

• Inicializar la función–: cargar el archivo de controlador y ejecutar cualquier código global o estático en él.
Las funciones deben crear los recursos estáticos, como clientes SDK y conexiones de bases de datos,
una vez, y después volver a utilizarlos para varias invocaciones.
• Gestionar errores–: si se produce un error, llamar a la API de error de inicialización (p. 126) y salir de
forma inmediata.

La inicialización se tiene en cuenta al calcular el tiempo de ejecución y el tiempo de espera que se factura.
Cuando una ejecución activa la inicialización de una nueva instancia de la función, puede ver el tiempo de
inicialización en los registros y el rastreo de AWS X-Ray (p. 404).

Example Log

REPORT RequestId: f8ac1208... Init Duration: 48.26 ms Duration: 237.17 ms Billed

Duration: 300 ms Memory Size: 128 MB Max Memory Used: 26 MB

Mientras se ejecuta, el tiempo de ejecución utiliza la interfaz de tiempo de ejecución de Lambda (p. 124)
para administrar eventos entrantes e informar sobre errores. Después de completar las tareas de
inicialización, el tiempo de ejecución procesa los eventos entrantes en bucle. En el código de tiempo de
ejecución, realice los siguientes pasos en orden.

Procesamiento de tareas

• Obtener un evento–: llamar a la API de la siguiente invocación (p. 124) para obtener el siguiente
evento. El cuerpo de la respuesta contiene los datos del evento. Los encabezados de respuesta
contienen el ID de la solicitud y otra información.
• Propagar el encabezado de rastreo–: obtener el encabezado de rastreo de X-Ray desde el encabezado
Lambda-Runtime-Trace-Id en la respuesta de la API. Establezca la variable de entorno
_X_AMZN_TRACE_ID en el mismo valor para el SDK de X-Ray que se vaya a utilizar.
• Crear un objeto context–: crear un objeto con información de contexto a partir de las variables de entorno
y los encabezados en la respuesta de la API.
• Invocar el controlador de la función–: transferir el evento y el objeto context al controlador.
• Gestionar la respuesta–: llamar a la API de respuesta de invocación (p. 125) para publicar la respuesta
desde el controlador.
• Gestionar errores–: si se produce un error, llamar a la API de error de invocación (p. 125).
• Limpiar–: liberar recursos no utilizados, enviar datos a otros servicios o realizar tareas adicionales antes
de obtener el siguiente evento.

123
 AWS Lambda Guía para desarrolladores
Interfaz de tiempo de ejecución

Puede incluir el tiempo de ejecución del paquete de implementación de la función o distribuir el tiempo de
ejecución aparte en una capa de función. Para ver un tutorial de ejemplo, consulte Tutorial: Publicación de
un tiempo de ejecución personalizado (p. 126).

Interfaz de tiempo de ejecución de AWS Lambda

AWS Lambda proporciona una API HTTP para que los tiempos de ejecución personalizados (p. 121)
puedan recibir eventos de invocación desde Lambda y enviar los datos de respuesta dentro del entorno de
ejecución (p. 118) de Lambda.

La especificación de OpenAPI para la versión de la API de tiempo de ejecución 2018-06-01 está disponible
aquí: [Link].

Los tiempos de ejecución obtienen un punto de enlace desde la variable de entorno

AWS_LAMBDA_RUNTIME_API, añaden la versión de la API y utilizan las siguientes rutas de recursos para
interactuar con la API.

Example Solicitud

curl "[Link]

Recursos
• Siguiente invocación (p. 124)
• Respuesta de la invocación (p. 125)
• Error de invocación (p. 125)
• Error de inicialización (p. 126)

Siguiente invocación
Ruta: /runtime/invocation/next

Método: GET

Recupera un evento de invocación. El cuerpo de la respuesta contiene la carga a partir de la invocación,

la cual es un documento JSON que contiene datos de eventos del desencadenador de la función. Los
encabezados de la respuesta contienen datos adicionales sobre la invocación.

Encabezados de respuesta

• Lambda-Runtime-Aws-Request-Id: el ID de solicitud, el cual identifica la solicitud que ha

desencadenado la invocación de la función.

Por ejemplo, 8476a536-e9f4-11e8-9739-2dfe598c3fcd.

• Lambda-Runtime-Deadline-Ms: la fecha en la que la función agota su tiempo de espera en
milisegundos de tiempo Unix.

Por ejemplo, 1542409706888.

• Lambda-Runtime-Invoked-Function-Arn: el ARN de la función de Lambda, la versión o el alias
especificado en la invocación.

Por ejemplo, arn:aws:lambda:us-east-2:123456789012:function:custom-runtime.

• Lambda-Runtime-Trace-Id: el AWS X-Ray encabezado de rastreo.

124
 AWS Lambda Guía para desarrolladores
Respuesta de la invocación

Por ejemplo, Root=1-5bef4de7-

ad49b0e87f6ef6c87fc2e700;Parent=9a9197af755a6419;Sampled=1.
• Lambda-Runtime-Client-Context: en invocaciones desde AWS Mobile SDK, datos sobre la
aplicación cliente y el dispositivo.
• Lambda-Runtime-Cognito-Identity: para invocaciones desde AWS Mobile SDK, datos sobre el
proveedor de identidades de Amazon Cognito.

Llame a /runtime/invocation/next para obtener el evento de invocación y pasarlo al controlador

de la función para su procesamiento. No establezca un tiempo de espera en la llamada a GET. Mientras
Lambda arranca el tiempo de ejecución y mientras el tiempo de ejecución tiene un evento para devolver, el
proceso de tiempo de ejecución se congela durante varios segundos.

El ID de solicitud hace un seguimiento de la invocación dentro de Lambda. Utilícelo para especificar la

invocación al enviar la respuesta.

El encabezado de rastreo contiene el ID de rastreo, el ID principal y la decisión de muestreo. Si se

muestrea la solicitud, lo hace Lambda o un servicio ascendente. El tiempo de ejecución deberá definir el
valor _X_AMZN_TRACE_ID con el valor del encabezado. El SDK de X-Ray lee esto para obtener los ID y
determinar si hay que rastrear la solicitud.

Respuesta de la invocación
Ruta: /runtime/invocation/AwsRequestId/response

Método: POST

Envía una respuesta de invocación a Lambda. Una vez que el tiempo de ejecución invoca el controlador
de la función, publica la respuesta de la función en la ruta de respuesta de la invocación. En el caso de
invocaciones síncronas, Lambda envía después la respuesta de vuelta al cliente.

Example Solicitud correcta

REQUEST_ID=156cb537-e2d4-11e8-9b34-d36013741fb9
curl -X POST "[Link]
response" -d "SUCCESS"

Error de invocación
Ruta: /runtime/invocation/AwsRequestId/error

Método: POST

Si la función devuelve un error, el tiempo de ejecución da formato de documento JSON al error y lo publica
en la ruta de error de invocación.

Example Cuerpo de la solicitud

{
"errorMessage" : "Error parsing event data.",
"errorType" : "InvalidEventDataException"
}

Example Solicitud errónea

REQUEST_ID=156cb537-e2d4-11e8-9b34-d36013741fb9

125
 AWS Lambda Guía para desarrolladores
Error de inicialización

ERROR="{\"errorMessage\" : \"Error parsing event data.\", \"errorType\" :

\"InvalidEventDataException\"}"
curl -X POST "[Link]
error" -d "$ERROR" --header "Lambda-Runtime-Function-Error-Type: Unhandled"

Error de inicialización
Ruta: /runtime/init/error

Método: POST

Si el tiempo de ejecución encuentra un error durante el proceso de inicialización, publica un mensaje de

error en la ruta de error de inicialización.

Example Solicitud de inicialización con error

ERROR="{\"errorMessage\" : \"Failed to load function.\", \"errorType\" :

\"InvalidFunctionException\"}"
curl -X POST "[Link] -d "$ERROR"
--header "Lambda-Runtime-Function-Error-Type: Unhandled"

Tutorial: Publicación de un tiempo de ejecución

personalizado
En este tutorial creará una función de Lambda con un tiempo de ejecución personalizado. Para empezar
incluirá el tiempo de ejecución en el paquete de implementación de la función. A continuación, lo migrará
a una capa que gestiona independientemente de la función. Por último, compartirá la capa de tiempo de
ejecución globalmente actualizando su política de permisos basados en recursos.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Necesita un rol de IAM para crear una función de Lambda. El rol necesita permiso para enviar registros
a CloudWatch Logs y acceder a los servicios de AWS que utilizan la función. Si no tiene un rol para el
desarrollo de funciones, cree uno.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).

126
 AWS Lambda Guía para desarrolladores
Crear una función

3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Crear una función

Cree una función de Lambda con un tiempo de ejecución personalizado. En este ejemplo se incluyen
dos archivos, un archivo de tiempo de ejecución bootstrap y un controlador de la función. Ambos se
implementan en Bash.

El tiempo de ejecución carga un script de función desde el paquete de implementación. Utiliza dos
variables para localizar el script. LAMBDA_TASK_ROOT le indica dónde se extrajo el paquete y _HANDLER
incluye el nombre del script.

Example arranque

#!/bin/sh

set -euo pipefail

# Initialization - load function handler

source $LAMBDA_TASK_ROOT/"$(echo $_HANDLER | cut -d. -f1).sh"

# Processing
while true
do
HEADERS="$(mktemp)"
# Get an event
EVENT_DATA=$(curl -sS -LD "$HEADERS" -X GET "[Link]
runtime/invocation/next")
REQUEST_ID=$(grep -Fi Lambda-Runtime-Aws-Request-Id "$HEADERS" | tr -d '[:space:]' | cut
-d: -f2)

# Execute the handler function from the script

RESPONSE=$($(echo "$_HANDLER" | cut -d. -f2) "$EVENT_DATA")

# Send the response

curl -X POST "[Link]
response" -d "$RESPONSE"
done

Tras cargar el script, el tiempo de ejecución procesa los eventos en bucle. Utiliza la API de tiempo de
ejecución para recuperar un evento de invocación de Lambda, pasa el evento al controlador y publica
la respuesta de vuelta en Lambda. Para obtener el ID de la solicitud, el tiempo de ejecución guarda los
encabezados de la respuesta de la API en un archivo temporal y lee el encabezado Lambda-Runtime-
Aws-Request-Id del archivo.
Note
Los tiempos de ejecución se encargan de algunas cosas más, como gestionar errores y
proporcionar información de contexto al controlador. Para obtener información, consulte Creación
de un tiempo de ejecución personalizado (p. 122).

El script define una función de controlador que toma datos de eventos, la registra en stderr y la devuelve.

127
 AWS Lambda Guía para desarrolladores
Crear una capa

Example [Link]

function handler () {
EVENT_DATA=$1
echo "$EVENT_DATA" 1>&2;
RESPONSE="Echoing request: '$EVENT_DATA'"

echo $RESPONSE
}

Guarde ambos archivos en un directorio de proyecto llamado runtime-tutorial.

runtime-tutorial
# bootstrap
# [Link]

Haga los archivos ejecutables y añádalos a un archivo ZIP.

runtime-tutorial$ chmod 755 [Link] bootstrap

runtime-tutorial$ zip [Link] [Link] bootstrap
adding: [Link] (deflated 24%)
adding: bootstrap (deflated 39%)

Cree una función llamada bash-runtime.

runtime-tutorial$ aws lambda create-function --function-name bash-runtime \

--zip-file fileb://[Link] --handler [Link] --runtime provided \
--role arn:aws:iam::123456789012:role/lambda-role
{
"FunctionName": "bash-runtime",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:bash-runtime",
"Runtime": "provided",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "mv/xRv84LPCxdpcbKvmwuuFzwo7sLwUO1VxcUv3wKlM=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "PassThrough"
},
"RevisionId": "2e1d51b0-6144-4763-8e5c-7d5672a01713",
...
}

Invoque la función y verifique la respuesta.

runtime-tutorial$ aws lambda invoke --function-name bash-runtime --payload

'{"text":"Hello"}' [Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
runtime-tutorial$ cat [Link]
Echoing request: '{"text":"Hello"}'

Crear una capa

Para separar el código de tiempo de ejecución del código de la función, cree una capa que solo
contenga el tiempo de ejecución. Las capas le permiten desarrollar las dependencias de la función de

128
 AWS Lambda Guía para desarrolladores
Actualización de la función

forma independiente y, si utiliza la misma capa con varias funciones, podrá hacer un menor uso del
almacenamiento.

Cree un archivo de capa que contenga el archivo bootstrap.

runtime-tutorial$ zip [Link] bootstrap

adding: bootstrap (deflated 39%)

Cree una capa con el comando publish-layer-version.

runtime-tutorial$ aws lambda publish-layer-version --layer-name bash-runtime --zip-file

fileb://[Link]
{
"Content": {
"Location": "[Link]
snapshots/123456789012/bash-runtime-018c209b...",
"CodeSha256": "bXVLhHi+D3H1QbDARUVPrDwlC7bssPxySQqt1QZqusE=",
"CodeSize": 584,
"UncompressedCodeSize": 0
},
"LayerArn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime",
"LayerVersionArn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:1",
"Description": "",
"CreatedDate": "2018-11-28T07:49:14.476+0000",
"Version": 1
}

Esto crea la primera versión de la capa.

Actualización de la función
Para utilizar la capa de tiempo de ejecución con la función, configure la función para que use la capa y, a
continuación, elimine de ella el código de tiempo de ejecución.

Actualice la configuración de la función para incluir la capa.

runtime-tutorial$ aws lambda update-function-configuration --function-name bash-runtime \

--layers arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:1
{
"FunctionName": "bash-runtime",
"Layers": [
{
"Arn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:1",
"CodeSize": 584,
"UncompressedCodeSize": 679
}
]
...
}

Esto agrega el tiempo de ejecución a la función en el directorio /opt. Lambda utiliza este tiempo de
ejecución, pero solo si se elimina del paquete de implementación de la función. Actualice el código de la
función para que incluya solo el script del controlador.

runtime-tutorial$ zip [Link] [Link]

adding: [Link] (deflated 24%)
runtime-tutorial$ aws lambda update-function-code --function-name bash-runtime --zip-file
fileb://[Link]
{

129
 AWS Lambda Guía para desarrolladores
Actualización del tiempo de ejecución

"FunctionName": "bash-runtime",
"CodeSize": 270,
"Layers": [
{
"Arn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:7",
"CodeSize": 584,
"UncompressedCodeSize": 679
}
]
...
}

Invoque la función de para verificar que funciona con la capa de tiempo de ejecución.

runtime-tutorial$ aws lambda invoke --function-name bash-runtime --payload

'{"text":"Hello"}' [Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
runtime-tutorial$ cat [Link]
Echoing request: '{"text":"Hello"}'

Actualización del tiempo de ejecución

Para registrar información sobre el entorno de ejecución, actualice el script de tiempo de ejecución para
emitir variables de entorno.

Example arranque

#!/bin/sh

set -euo pipefail

echo "## Environment variables:"

env

# Initialization - load function handler

source $LAMBDA_TASK_ROOT/"$(echo $_HANDLER | cut -d. -f1).sh"
...

Cree una segunda versión de la capa con el nuevo código.

runtime-tutorial$ zip [Link] bootstrap

updating: bootstrap (deflated 39%)
runtime-tutorial$ aws lambda publish-layer-version --layer-name bash-runtime --zip-file
fileb://[Link]

Configure la función para utilizar la nueva versión de la capa.

runtime-tutorial$ aws lambda update-function-configuration --function-name bash-runtime \

--layers arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:2

Uso compartido de la capa

Añada una instrucción de permiso a la capa de tiempo de ejecución para compartirla con otras cuentas.

130
 AWS Lambda Guía para desarrolladores
Eliminación

runtime-tutorial$ aws lambda add-layer-version-permission --layer-name bash-runtime --

version-number 2 \
--principal "*" --statement-id publish --action lambda:GetLayerVersion
{
"Statement": "{\"Sid\":\"publish\",\"Effect\":\"Allow\",\"Principal\":\"*\",\"Action\":
\"lambda:GetLayerVersion\",\"Resource\":\"arn:aws:lambda:us-west-2:123456789012:layer:bash-
runtime:2\"}",
"RevisionId": "9d5fe08e-2a1e-4981-b783-37ab551247ff"
}

Puede agregar varias instrucciones de manera que cada una conceda permiso a una única cuenta,
cuentas de una organización o todas las cuentas.

Eliminación
Elimine cada versión de la capa.

runtime-tutorial$ aws lambda delete-layer-version --layer-name bash-runtime --version-

number 1
runtime-tutorial$ aws lambda delete-layer-version --layer-name bash-runtime --version-
number 2

Puesto que la función contiene una referencia a la versión 2 de la capa, esta sigue existiendo en Lambda.
Si bien la función sigue funcionando, ya no se pueden configurar funciones para que utilicen la versión
eliminada. Si después modifica la lista de capas en la función, deberá especificar una nueva versión u
omitir la capa eliminada.

Elimine la función del tutorial con el comando delete-function.

runtime-tutorial$ aws lambda delete-function --function-name bash-runtime

131
 AWS Lambda Guía para desarrolladores
Administración de aplicaciones

Aplicaciones de AWS Lambda

Una aplicación AWS Lambda es una combinación de funciones, orígenes de eventos y otros recursos de
Lambda que se combinan para realizar tareas. Puede utilizar AWS CloudFormation y otras herramientas
para recopilar los componentes de su aplicación en un solo paquete que se puede implementar y
administrar como un recurso. Las aplicaciones hacen portables sus proyectos de Lambda y le permiten
realizar la integración con herramientas adicionales para desarrolladores, como AWS CodePipeline, AWS
CodeBuild, y la interfaz de línea de comandos de Modelo de aplicación sin servidor de AWS (SAM CLI).

AWS Serverless Application Repository proporciona una recopilación de aplicaciones Lambda que puede
implementar en su cuenta con tan solo unos clics. El repositorio incluye tanto aplicaciones listas para usar
como muestras que puede utilizar como punto de partida para sus propios proyectos. También puede
enviar sus propios proyectos para su inclusión.

AWS CloudFormation le permite crear una plantilla que defina los recursos de su aplicación y le permita
administrar la aplicación como una pila. Puede agregar o modificar recursos de forma más segura en su
pila de aplicaciones. Si se produce un fallo en alguna parte de una actualización, AWS CloudFormation
restaura automáticamente a la configuración anterior. Con los parámetros de AWS CloudFormation, puede
crear varios entornos para la aplicación a partir de la misma plantilla. AWS SAM (p. 28) amplía AWS
CloudFormation con una sintaxis simplificada centrada en el desarrollo de aplicaciones de Lambda.

La AWS CLI (p. 28) y SAM CLI (p. 29) son herramientas de línea de comandos para la administración de
pilas de aplicaciones de Lambda. Además de comandos para la administración de pilas de aplicaciones
con la API de AWS CloudFormation, AWS CLI admite los comandos de nivel superior, que simplifican
tareas como la carga de paquetes de implementación y la actualización de plantillas. El CLI AWS SAM
proporciona funcionalidad adicional, que incluye validación de plantillas y pruebas de forma local.

Temas
• Administración de aplicaciones en la consola de AWS Lambda (p. 132)
• Creación de una aplicación con entrega continua en la consola de Lambda (p. 135)
• Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141)
• Implementaciones continuas para funciones de Lambda (p. 145)
• Tipos de aplicaciones de Lambda y casos de uso comunes (p. 147)
• Prácticas recomendadas para trabajar con funciones de AWS Lambda (p. 149)

Administración de aplicaciones en la consola de

AWS Lambda
La consola de AWS Lambda le ayuda a monitorizar y administrar sus aplicaciones de Lambda (p. 132).
El menú Applications (Aplicaciones) muestra las pilas de AWS CloudFormation con funciones de Lambda.
El menú incluye pilas que lanza en AWS CloudFormation mediante la consola de AWS CloudFormation, el
AWS Serverless Application Repository, la AWS CLI o la CLI de AWS SAM.

Para ver una aplicación de Lambda

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

132
 AWS Lambda Guía para desarrolladores
Monitorización de aplicaciones

2. Elija una aplicación.

La información general muestra la siguiente información sobre la aplicación.

• Plantilla de AWS CloudFormation o plantilla de SAM: la plantilla que define la aplicación.

• Resources (Recursos): los recursos de AWS que se definen en la plantilla de la aplicación. Para
administrar las funciones de Lambda, elija un nombre de función de la lista.

Monitorización de aplicaciones
La pestaña Monitoring (Monitorización) muestra un panel Amazon CloudWatch con métricas para los
recursos de la aplicación.

Para monitorizar una aplicación de Lambda

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija Monitoring.

De forma predeterminada, la consola de Lambda muestra un panel básico. Puede personalizar esta página
definiendo tableros personalizados en su plantilla de aplicación. Si su plantilla incluye uno o varios paneles,
la página le mostrará sus paneles en lugar del panel predeterminado. Puede cambiar entre los paneles con
el menú desplegable en la parte superior derecha de la página.

Paneles personalizados de monitorización

Personalice su página de monitorización de aplicaciones agregando uno o varios paneles de Amazon
CloudWatch a su plantilla de aplicación el tipo de recurso de AWS:: CloudWatch:: Dashboard. En el
siguiente ejemplo se crea un panel con un único widget que crea gráficos del número de invocaciones de
una función denominada my-function.

Example Plantilla de panel de funciones

Resources:
MyDashboard:
Type: AWS::CloudWatch::Dashboard
Properties:
DashboardName: my-dashboard
DashboardBody: |
{
"widgets": [
{
"type": "metric",
"width": 12,

133
 AWS Lambda Guía para desarrolladores
Paneles personalizados de monitorización

"height": 6,
"properties": {
"metrics": [
[
"AWS/Lambda",
"Invocations",
"FunctionName",
"my-function",
{
"stat": "Sum",
"label": "MyFunction"
}
],
[
{
"expression": "SUM(METRICS())",
"label": "Total Invocations"
}
]
],
"region": "us-east-1",
"title": "Invocations",
"view": "timeSeries",
"stacked": false
}
}
]
}

Puede obtener la definición de cualquiera de los widgets del panel de monitorización predeterminado
desde la consola de CloudWatch.

Para ver una definición de widget

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija una aplicación que tenga el panel estándar.
3. Elija Monitoring.
4. En cualquier widget, elija View in metrics (Ver en métricas) en el menú desplegable.

5. Elija Source.

Para obtener más información acerca de la creación de paneles y widgets de CloudWatch, consulte el
tema relacionado con la estructura y la sintaxis del cuerpo de los paneles en la referencia de la API de
Amazon CloudWatch ..

134
 AWS Lambda Guía para desarrolladores
Tutorial: Crear una aplicación

Creación de una aplicación con entrega continua en

la consola de Lambda
Puede utilizar la consola de Lambda para crear una aplicación con una canalización de entrega continua
integrada. Con la entrega continua, cada cambio que se envía al repositorio de control de código fuente
desencadena una canalización que genera e implementa la aplicación automáticamente. La consola
de Lambda proporciona proyectos de inicio para tipos de aplicaciones comunes con código de ejemplo
[Link] y plantillas que crean recursos de soporte.

En este tutorial, se crean los recursos siguientes.

• Aplicación: una función de [Link] de Lambda, especificación de compilación y plantilla de Modelo de

aplicación sin servidor de AWS (AWS SAM).
• Canalización: una canalización de AWS CodePipeline que conecta los demás recursos para habilitar la
entrega continua.
• Repository (Repositorio): repositorio de Git en AWS CodeCommit. Cuando se envía un cambio, la
canalización copia el código fuente en un bucket de Amazon S3 y se lo pasa al proyecto de compilación.
• Disparador: una regla de Amazon CloudWatch Events que vigila la rama principal del repositorio y activa
la canalización.
• Proyecto de compilación: compilación de AWS CodeBuild que obtiene el código fuente de la canalización
y empaqueta la aplicación. El código fuente incluye una especificación de compilación con comandos
que instalan las dependencias y preparan una plantilla de la aplicación para la implementación.
• Configuración de implementación: la etapa de implementación de la canalización define un conjunto de
acciones que toman la plantilla de AWS SAM procesada de la salida de compilación e implementan la
nueva versión con AWS CloudFormation.
• Bucket: un bucket de Amazon Simple Storage Service (Amazon S3) para el almacenamiento de
artefactos de implementación.
• Roles: las etapas de origen, compilación e implementación de la canalización tienen roles de IAM que
les permiten administrar recursos de AWS. La función de la aplicación tiene un rol de ejecución (p. 32)
que le permite cargar registros y se puede ampliar para acceder a otros servicios.

Los recursos de la aplicación y la canalización se definen en plantillas de AWS CloudFormation que se

pueden personalizar y ampliar. El repositorio de aplicaciones incluye una plantilla que puede modificar para
agregar tablas de Amazon DynamoDB, una API de Amazon API Gateway y otros recursos de aplicación.
La canalización de entrega continua se define en una plantilla separada fuera del control de origen y tiene
su propia pila.

La canalización asigna una única ramificación de un repositorio a una única pila de aplicación. Puede
crear canalizaciones adicionales para agregar entornos para otras ramificaciones del mismo repositorio.
También puede añadir etapas a la canalización para pruebas, ensayo y las aprobaciones manuales. Para
obtener más información acerca de AWS CodePipeline, consulte ¿Qué es AWS CodePipeline?.

Secciones
• Requisitos previos (p. 136)
• Creación de una aplicación (p. 136)
• Invocación de la función (p. 136)
• Agregar un recurso de AWS (p. 137)
• Actualizar el límite de permisos (p. 138)
• Actualizar el código de la función (p. 138)
• Pasos siguientes (p. 140)

135
 AWS Lambda Guía para desarrolladores
Requisitos previos

• Solución de problemas (p. 140)

• Eliminación (p. 141)

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Este tutorial utiliza CodeCommit para el control de código fuente. Para configurar el equipo local para
acceder y actualizar el código de la aplicación, consulte Configuración en la Guía del usuario de AWS
CodeCommit.

Creación de una aplicación

Cree una aplicación en la consola de Lambda.

Para crear una aplicación

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija Create application.
3. Elija Author from scratch.
4. Configure los ajustes de la aplicación.

• Nombre de la aplicación: my-app.

• Descripción de la aplicación: my application.
• Tiempo de ejecución: [Link] 10.x.
• Servicio de control de origen: CodeCommit.
• Nombre del repositorio: my-app-repo.
• Permisos: Crear roles y límite de permisos.
5. Seleccione Create.

Lambda crea la canalización y los recursos relacionados y confirma el código de la aplicación de muestra
en el repositorio de Git. A medida que se crean los recursos, aparecen en la página de información
general.

Invocación de la función
Invoque la función para verificar que funciona.

136
 AWS Lambda Guía para desarrolladores
Agregar un recurso de AWS

Invocación de la función de la aplicación

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Seleccione my-app.
3. En Resources (Recursos), elija helloFromLambdaFunction.
4. Elija Test.
5. Configure un evento de prueba.

• Event name (Nombre de evento): test

• Body (Cuerpo): {}
6. Seleccione Create.
7. Elija Test.

La consola de Lambda ejecuta la función y muestra el resultado. Expanda la sección Details (Detalles)
debajo del resultado para ver los detalles de salida y ejecución.

Agregar un recurso de AWS

Cuando cree su aplicación, la consola de Lambda crea un repositorio de Git que contiene la aplicación
de ejemplo. Para obtener una copia del código de la aplicación en su equipo local, clone el repositorio del
proyecto.

Para clonar el repositorio del proyecto

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Seleccione my-app.
3. Seleccione Code (Código).
4. En Repository details (Detalles del repositorio), copie el URI del repositorio HTTP o SSH, en función
del modo de autenticación que haya configurado durante la configuración (p. 136).
5. Clone el repositorio.

~$ git clone ssh://[Link]/v1/repos/my-app-repo

El repositorio contiene la plantilla para la aplicación, una especificación de compilación y código. Agregue
una tabla de DynamoDB a la plantilla de la aplicación.

Para agregar una tabla de DynamoDB

1. Abra [Link] en un editor de texto.

2. Agregue un recurso de tabla, una variable de entorno que transmita el nombre de la tabla a la función
y una política de permisos que permita administrarla a la función.

Example [Link] - Recursos

...
Resources:
ddbTable:
Type: AWS::Serverless::SimpleTable
Properties:
PrimaryKey:
Name: id
Type: String
ProvisionedThroughput:

137
 AWS Lambda Guía para desarrolladores
Actualizar el límite de permisos

ReadCapacityUnits: 1
WriteCapacityUnits: 1
helloFromLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: src/handlers/[Link]
Runtime: nodejs10.x
MemorySize: 128
Timeout: 100
Description: This is a hello from Lambda example.
Environment:
Variables:
DDB_TABLE: !Ref ddbTable
Policies:
- DynamoDBCrudPolicy:
TableName: !Ref ddbTable
- AWSLambdaBasicExecutionRole

3. Confirmar y enviar el cambio.

~/my-app-repo$ git commit -am "Add DynamoDB table"

~/my-app-repo$ git push

Cuando se envía un cambio, se activa la canalización de la aplicación. Utilice la pestaña Deployments

(Implementaciones) de la pantalla de la aplicación para realizar un seguimiento del cambio a medida que
se transmite a través de la canalización. Una vez finalizada la implementación, continúe en el siguiente
paso.

Actualizar el límite de permisos

La aplicación de ejemplo aplica un límite de permisos al rol de ejecución de su función. El límite de
permisos limita los permisos que puede agregar al rol de la función. Sin el límite, los usuarios con acceso
de escritura al repositorio del proyecto podrían modificar la plantilla del proyecto para dar permiso a la
función para acceder a recursos y servicios fuera del ámbito de la aplicación de muestra.

Para que la función utilice el permiso de DynamoDB que agregó a su rol de ejecución en el paso anterior,
debe extender el límite de permisos para permitir los permisos adicionales. La consola de Lambda detecta
recursos que no están en el límite de permisos y proporciona una directiva actualizada que puede usar
para actualizarla.

Para actualizar el límite de permisos de la aplicación

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija su aplicación.
3. En Resources (Recursos), elija Edit permissions boundary (Editar límite de permisos).
4. Siga las instrucciones que se muestran para actualizar el límite y permitir el acceso a la nueva tabla.

Para obtener más información sobre los límites de permisos, consulte Uso de límites de permisos para
aplicaciones de AWS Lambda (p. 49).

Actualizar el código de la función

A continuación, actualice el código de función para usar la tabla. El código siguiente utiliza la tabla para
realizar un seguimiento del número de invocaciones procesadas por cada instancia de la función. Utiliza el
ID de flujo de registro como identificador único. Las nuevas instancias se crean al actualizar una función y
para gestionar varias invocaciones simultáneas.

138
 AWS Lambda Guía para desarrolladores
Actualizar el código de la función

Para actualizar el código de la función

1. Agregue un nuevo controlador denominado [Link] a la carpeta src/handlers con el siguiente

contenido.

Example src/handlers/[Link]

const dynamodb = require('aws-sdk/clients/dynamodb');

const docClient = new [Link]();

[Link] = async (event, context) => {

const message = 'Hello from Lambda!';
const tableName = [Link].DDB_TABLE;
const logStreamName = [Link];
var params = {
TableName : tableName,
Key: { id : logStreamName },
UpdateExpression: 'set invocations = if_not_exists(invocations, :start)
+ :inc',
ExpressionAttributeValues: {
':start': 0,
':inc': 1
},
ReturnValues: 'ALL_NEW'
};
await [Link](params).promise();

const response = {
body: [Link](message)
};
[Link](`body: ${[Link]}`);
return response;
}

2. Abra la plantilla de la aplicación y cambie el valor del controlador a src/handlers/

[Link].

Example [Link]

...
helloFromLambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: src/handlers/[Link]
Runtime: nodejs10.x

3. Confirmar y enviar el cambio.

~/my-app-repo$ git add . && git commit -m "Use DynamoDB table"

~/my-app-repo$ git push

Después de implementar el cambio de código, invoque la función varias veces para actualizar la tabla
DynamoDB.

Para ver la tabla DynamoDB

1. Abra la página Tables (Tablas) de la consola de DynamoDB.

2. Elija la tabla que comienza por my-app.
3. Seleccione Items (Elementos).

139
 AWS Lambda Guía para desarrolladores
Pasos siguientes

4. Haga clic en Start search (Iniciar búsqueda).

Pasos siguientes
La plantilla de AWS CloudFormation que define los recursos de la aplicación utiliza la transformación de
Modelo de aplicación sin servidor de AWS para simplificar la sintaxis de las definiciones de recursos y
automatizar la carga del paquete de implementación y otros artefactos. AWS SAM también proporciona
una interfaz de línea de comandos (la CLI de AWS SAM), que tiene la misma funcionalidad de
empaquetado e implementación que la AWS CLI, con características adicionales específicas para las
aplicaciones Lambda. Utilice la CLI de AWS SAM para probar su aplicación localmente en un contenedor
Docker que emula el entorno de ejecución de Lambda.

• Instalación de la CLI de AWS SAM

• Prueba y depuración de aplicaciones sin servidor

AWS Cloud9 proporciona un entorno de desarrollo online que incluye [Link], la CLI de AWS SAM
y Docker. Con AWS Cloud9, puede comenzar a desarrollar rápidamente y acceder a su entorno de
desarrollo desde cualquier equipo. Para obtener instrucciones, consulte Introducción en la Guía del usuario
de AWS Cloud9.

Para el desarrollo local, los conjuntos de herramientas de AWS para entornos de desarrollo integrados
(IDE) le permiten probar y depurar funciones antes de insertarlas en su repositorio.

• AWS Toolkit for JetBrains: plugin para IDE de PyCharm (Python) e IntelliJ (Java).
• AWS Toolkit for Eclipse: plugin para IDE de Eclipse (varios idiomas).
• AWS Toolkit for Visual Studio Code: plugin para IDE de Visual Studio Code (varios idiomas).
• AWS Toolkit for Visual Studio: plugin para IDE de Visual Studio (varios idiomas).

Solución de problemas
A medida que desarrolle su aplicación, es probable que encuentre los siguientes tipos de errores.

• Errores de compilación: problemas que se producen durante la fase de compilación, incluidos errores de
compilación, prueba y empaquetado.
• Errores de implementación: problemas que se producen cuando AWS CloudFormation no puede
actualizar la pila de aplicaciones. Estos incluyen errores de permisos, límites de cuenta, problemas de
servicio o errores de plantilla.
• Errores de invocación: errores devueltos por el código o tiempo de ejecución de una función.

Para errores de compilación e implementación, puede identificar la causa de un error en la consola de

Lambda.

Para solucionar errores de aplicación

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija una aplicación.
3. Elija Deployments (Implementaciones).
4. Para ver la canalización de la aplicación, elija Deployment pipeline (Canalización de implementación).
5. Identifique la acción que encontró un error.
6. Para ver el error en contexto, elija Details (Detalles).

140
 AWS Lambda Guía para desarrolladores
Eliminación

Para los errores de implementación que se producen durante la acción ExecuteChangeSet, la canalización
se vincula a una lista de eventos de pila en la consola de AWS CloudFormation. Busque un evento con
el estado UPDATE_FAILED. Dado que AWS CloudFormation vuelve al estado anterior después de un
error, el evento pertinente está debajo de otros eventos en la lista. Si AWS CloudFormation no pudo crear
un conjunto de cambios, el error aparece en Change sets (Conjuntos de cambios) en lugar de en Events
(Eventos).

Una causa común de errores de implementación e invocación es la falta de permisos en uno o más roles.
La canalización tiene un rol para implementaciones (CloudFormationRole) equivalente a los permisos
de usuario (p. 41) que utilizaría para actualizar una pila de AWS CloudFormation directamente. Si agrega
recursos a la aplicación o habilita características de Lambda que requieren permisos de usuario, se
utiliza el rol de implementación. Puede encontrar un vínculo al rol de implementación en Infrastructure
(Infraestructura) en la información general de la aplicación.

Si su función accede a otros servicios o recursos de AWS, o si habilita las características que requieren
que la función tenga permisos adicionales, se utilizará el rol de ejecución (p. 32) de la función. Todos los
roles de ejecución que se crean en la plantilla de aplicación también están sujetos al límite de permisos de
la aplicación. Este límite requiere que conceda explícitamente acceso a servicios y recursos adicionales en
IAM después de agregar permisos al rol de ejecución en la plantilla.

Por ejemplo, para conectar una función a una nube privada virtual (p. 78) (VPC), necesita permisos
de usuario para describir los recursos de VPC. El rol de ejecución necesita permiso para administrar
interfaces de red. Esto requiere los siguientes pasos.

1. Agregue los permisos de usuario necesarios al rol de implementación en IAM.

2. Agregue los permisos de rol de ejecución al límite de permisos en IAM.
3. Agregue los permisos de rol de ejecución a la función de ejecución en la plantilla de aplicación.
4. Confirme e inserte para implementar el rol de ejecución actualizado.

Después de corregir los errores de permisos, elija Release change (Cambio de versión) en la información
general de la canalización para volver a ejecutar la compilación y la implementación.

Eliminación
Puede seguir modificando y utilizar la muestra para desarrollar su propia aplicación. Si ha terminado
de usar la muestra, elimine la aplicación para evitar pagar por la canalización, el repositorio y el
almacenamiento.

Para eliminar la aplicación

1. Abra la consola de AWS CloudFormation.

2. Elimine la pila de la aplicación – my-app.
3. Abra la consola de Amazon S3.
4. Elimine el bucket de artefacto – aws-us-east-2-123456789012-my-app-pipe.
5. Vuelva a la consola de AWS CloudFormation y elimine la pila de infraestructura: serverlessrepo-my-
app-toolchain.

Aplicación de ejemplo de procesamiento de errores

para AWS Lambda
La aplicación de ejemplo de procesamiento de errores demuestra el uso de AWS Lambda para controlar
los eventos procedentes de una suscripción de Amazon CloudWatch Logs (p. 190). CloudWatch Logs

141
 AWS Lambda Guía para desarrolladores
Arquitectura y estructura de eventos

le permite invocar una función de Lambda cuando una entrada de registro coincide con un patrón. La
suscripción de esta aplicación monitoriza las entradas del grupo de registros de una función que contienen
la palabra ERROR. Como respuesta, invoca una función de Lambda de procesamiento. La función de
procesamiento recupera el flujo de registros y los datos de rastreo completos de la solicitud que ha
provocado el error y los almacena para su uso posterior.

El código de la función está disponible en los siguientes archivos:

• Generador de errores aleatorios: random-error/[Link]

• Procesador: processor/[Link]

Puede implementar el ejemplo en unos minutos con la AWS CLI y con AWS CloudFormation. Siga las
instrucciones del archivo README para descargarla, configurarla e implementarla en su cuenta.

Secciones
• Arquitectura y estructura de eventos (p. 142)
• Instrumentación con AWS X-Ray (p. 143)
• Plantilla de AWS CloudFormation y recursos adicionales (p. 144)

Arquitectura y estructura de eventos

La aplicación de ejemplo utiliza los siguientes servicios de AWS.

• AWS Lambda: ejecuta el código de la función, envía los registros de CloudWatch Logs y envía los datos
de rastreo a X-Ray.
• Amazon CloudWatch Logs: recopila los registros e invoca una función cuando una entrada de registro
coincide con un patrón de filtro.
• AWS X-Ray: recopila datos de rastreo, indexa los rastros para las búsquedas y genera un mapa de
servicio.
• Amazon Simple Storage Service (Amazon S3): almacena los artefactos de implementación y la salida de
la aplicación.
• AWS CloudFormation: crea los recursos de la aplicación e implementa el código de la función.

142
 AWS Lambda Guía para desarrolladores
Instrumentación con AWS X-Ray

Una función de Lambda en la aplicación genera errores de forma aleatoria. Cuando CloudWatch Logs
detecta la palabra ERROR en los registros de la función, envía un evento a la función de procesamiento
para su procesamiento.

Example – Evento de mensaje de CloudWatch Logs

{
"awslogs": {
"data": "H4sIAAAAAAAAAHWQT0/DMAzFv0vEkbLYcdJkt4qVXmCDteIAm1DbZKjS
+kdpB0Jo350MhsQFyVLsZ+unl/fJWjeO5asrPgbH5..."
}
}

Una vez descodificados, los datos contienen información sobre el evento del registro. La función utiliza
estos detalles para identificar el flujo de registros y analiza el mensaje del registro para obtener el ID de la
solicitud que ha provocado el error.

Example – Datos de eventos de CloudWatch Logs descodificados

{
"messageType": "DATA_MESSAGE",
"owner": "123456789012",
"logGroup": "/aws/lambda/lambda-error-processor-randomerror-1GD4SSDNACNP4",
"logStream": "2019/04/04/[$LATEST]63311769a9d742f19cedf8d2e38995b9",
"subscriptionFilters": [
"lambda-error-processor-subscription-15OPDVQ59CG07"
],
"logEvents": [
{
"id": "34664632210239891980253245280462376874059932423703429141",
"timestamp": 1554415868243,
"message": "2019-04-04T22:11:08.243Z\t1d2c1444-efd1-43ec-
b16e-8fb2d37508b8\tERROR\n"
}
]
}

La función de procesamiento utiliza la información del evento de CloudWatch Logs para descargar el flujo
de registros y el rastro de X-Ray completos para una solicitud que ha provocado un error. Almacena ambos
en un bucket de Amazon S3. Para permitir que finalicen el flujo de registros y tiempo de rastreo, la función
espera un breve periodo de tiempo antes de acceder a los datos.

Instrumentación con AWS X-Ray

La aplicación utiliza AWS X-Ray (p. 404) para rastrear las invocaciones de la función y las llamadas
que realizan las funciones a los servicios de AWS. X-Ray utiliza los datos de rastreo que recibe de las
funciones para crear un mapa de servicio que ayuda a identificar errores. El siguiente mapa de servicio
muestra la función de generación de errores aleatorios para algunas solicitudes. También muestra la
función de procesamiento que llama a X-Ray, CloudWatch Logs y Amazon S3.

143
 AWS Lambda Guía para desarrolladores
Plantilla de AWS CloudFormation y recursos adicionales

Las dos funciones de [Link] están configuradas para el rastreo activo en la plantilla y se instrumentan
con el SDK de AWS X-Ray para [Link] en el código. Con el rastreo activo, las etiquetas Lambda añaden
un encabezado de rastreo a las solicitudes entrantes y envían un rastro con los datos de tiempo a X-Ray.
Además, la función de generación de errores aleatorios utiliza el SDK de X-Ray para registrar el ID de la
solicitud y la información del usuario en las anotaciones. Las anotaciones se asocian al rastro y se pueden
utilizar para localizar el rastro de una solicitud específica.

La función de procesamiento obtiene el ID de la solicitud del evento de CloudWatch Logs y utiliza el

AWS SDK for JavaScript para buscar dicha solicitud en X-Ray. Utiliza los clientes del SDK de AWS,
instrumentados con el SDK de X-Ray, para descargar el rastro y el flujo de registros. A continuación,
los almacena en el bucket de salida. El SDK de X-Ray registra estas llamadas, que aparecen como
subsegmentos en el rastro.

Plantilla de AWS CloudFormation y recursos

adicionales
La aplicación se implementa en dos módulos de [Link]: una plantilla de AWS CloudFormation y los
scripts de shell necesarios. La plantilla crea la función de procesamiento, la función de generación de
errores aleatorios y los siguientes recursos complementarios.

• Rol de ejecución: rol de IAM que concede a las funciones permiso para tener acceso a otros servicios de
AWS.
• Función iniciadora: función adicional que invoca la función de generación de errores aleatorios para
crear un grupo de registros.
• Recurso personalizado: recurso personalizado de AWS CloudFormation que invoca la función iniciadora
durante la implementación para asegurarse de que el grupo de registros existe.

144
 AWS Lambda Guía para desarrolladores
Implementaciones continuas

• Suscripción a CloudWatch Logs: suscripción al flujo de registros que activa la función de procesamiento
cuando se registra la palabra ERROR.
• Política basada en recursos: instrucción de permisos para la función de procesamiento que permite a
CloudWatch Logs invocarla.
• Bucket de Amazon S3: ubicación de almacenamiento para la salida de la función de procesamiento.

Vea la plantilla [Link] de GitHub.

Para solucionar una limitación de la integración de Lambda con AWS CloudFormation, la plantilla crea una
función adicional que se ejecuta durante las implementaciones. Todas las funciones de Lambda vienen
con un grupo de registros de CloudWatch Logs que almacena la salida de sus ejecuciones. Sin embargo,
el grupo de registros no se crea hasta que la función se invoca por primera vez.

Para crear la suscripción, que depende de la existencia del grupo de registros, la aplicación utiliza una
tercera función de Lambda para invocar la función de generación de errores aleatorios. La plantilla incluye
el código de la función iniciadora insertado. Un recurso de AWS CloudFormation personalizado la llama
durante la implementación. Las propiedades DependsOn permiten asegurarse de que el flujo de registros y
la política basada en recursos se han creado antes de la suscripción.

Implementaciones continuas para funciones de

Lambda
Utilice implementaciones continuas para controlar los riesgos asociados a la introducción de nuevas
versiones de su función de Lambda. En una implementación continua, el sistema implementa
automáticamente la nueva versión de la función y envía gradualmente una cantidad creciente de tráfico a
la nueva versión. La cantidad de tráfico y la tasa de aumento son parámetros que puede configurar.

Para configurar una implementación continua utilice AWS CodeDeploy y AWS SAM. CodeDeploy es un
servicio que automatiza las implementaciones de aplicaciones en plataformas informáticas de Amazon
como Amazon EC2 y AWS Lambda. Para obtener más información, consulte ¿Qué es CodeDeploy?. Al
utilizar CodeDeploy para implementar la función de Lambda, puede monitorizar fácilmente el estado de la
implementación e iniciar una restauración si detecta algún problema.

AWS SAM es un marco de código abierto para crear aplicaciones sin servidor. Cree una plantilla de
AWS SAM (en formato YAML) para especificar la configuración de los componentes necesarios para la

145
 AWS Lambda Guía para desarrolladores
Plantilla de AWS SAM de Lambda de ejemplo

implementación continua. AWS SAM utiliza la plantilla para crear y configurar los componentes. Para
obtener más información, consulte ¿Qué es el modelo de aplicación sin servidor de AWS?.

En una implementación continua, AWS SAM realiza las siguientes tareas:

• Configura su función de Lambda y crea un alias.

La configuración de direccionamiento de alias es la capacidad subyacente que implementa la

implementación continua.
• Crea una aplicación CodeDeploy y un grupo de implementación.

El grupo de implementación administra la implementación continua y la restauración (si es necesario).

• Detecta cuando crea una nueva versión de su función de Lambda.
• Activa CodeDeploy para iniciar la implementación de la nueva versión.

Plantilla de AWS SAM de Lambda de ejemplo

En el ejemplo siguiente se muestra una plantilla de AWS SAM para una implementación continua simple.

AWSTemplateFormatVersion : '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A sample SAM template for deploying Lambda functions.

Resources:
# Details about the myDateTimeFunction Lambda function
myDateTimeFunction:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
# Creates an alias named "live" for the function, and automatically publishes when you
update the function.
AutoPublishAlias: live
DeploymentPreference:
# Specifies the deployment configuration
Type: Linear10PercentEvery2Minutes

Esta plantilla define una función de Lambda denominada myDateTimeFunction con las siguientes
propiedades.

AutoPublishAlias

La propiedad AutoPublishAlias crea un alias denominado live. Además, el marco de AWS SAM
detecta automáticamente cuando guarda código nuevo para la función. A continuación, el marco
publica una nueva versión de función y actualiza el alias live para que apunte a la nueva versión.
DeploymentPreference

La propiedad DeploymentPreference determina la velocidad a la que la aplicación CodeDeploy

cambia el tráfico de la versión original de la función de Lambda a la nueva versión. El valor
Linear10PercentEvery2Minutes desplaza un diez por ciento adicional del tráfico a la nueva
versión cada dos minutos.

Para obtener una lista de las configuraciones de implementación predefinidas, consulte

Configuraciones de implementación.

Para obtener un tutorial detallado sobre cómo utilizar CodeDeploy con funciones de Lambda, consulte
Implementar una función de Lambda actualizada con CodeDeploy.

146
 AWS Lambda Guía para desarrolladores
Casos de uso

Tipos de aplicaciones de Lambda y casos de uso

comunes
Cuando se crean aplicaciones en AWS Lambda, los componentes principales son las funciones de
Lambda y los disparadores. Un disparador es el servicio de AWS o la aplicación que invoca una función, y
una función de Lambda es el código y el tiempo de ejecución que procesan eventos. A modo de ejemplo,
considere las siguientes situaciones:

• Procesamiento de archivos: supongamos que tiene una aplicación de uso compartido de fotografías. Los
usuarios utilizan la aplicación para cargar fotografías, y esta las almacena en un bucket de Amazon S3.
A continuación, la aplicación crea una versión en miniatura las fotografías de cada usuario y las muestra
en la página de perfil del usuario. En este caso, puede optar por crear una función de Lambda para crear
una miniatura automáticamente. Amazon S3 es uno de los orígenes de eventos de AWS que pueden
publicar eventos de creación de objetos e invocar una función de Lambda. El código de la función de
Lambda puede leer el objeto de fotografía del bucket de S3, crear una versión en miniatura y guardarla
en otro bucket de S3.
• Datos y análisis: supongamos que está creando una aplicación de análisis, y que almacena los datos
sin procesar en una tabla de DynamoDB. Cuando se escriben, actualizan o eliminan elementos de
una tabla, los flujos de DynamoDB pueden publicar eventos de actualización de elementos en un flujo
asociado a la tabla. En este caso, los datos del evento proporcionan la clave del elemento, el nombre del
evento (por ejemplo, insert, update y delete) y otros detalles. Puede escribir una función de Lambda que
genere métricas personalizadas agregando los datos sin procesar.
• Sitios web: supongamos que está creando un sitio web y que desea alojar la lógica del backend en
Lambda. Puede invocar la función de Lambda a través de HTTP utilizando Amazon API Gateway como
punto de enlace HTTP. A continuación, el cliente web puede invocar la API y, por último, API Gateway
puede dirigir la solicitud a Lambda.
• Aplicaciones móviles: supongamos que tiene una aplicación móvil personalizada que produce
eventos. Puede crear una función de Lambda para procesar los eventos publicados por la aplicación
personalizada. Por ejemplo, en este caso, puede configurar una función de Lambda para procesar los
clics que se realizan en la aplicación móvil personalizada.

AWS Lambda admite muchos servicios de AWS como orígenes de eventos. Para obtener más información,
consulte Uso de AWS Lambda con otros servicios (p. 153). Cuando se configuran estos orígenes de
eventos para activar una función de Lambda, la función de Lambda se invoca automáticamente cuando
se producen los eventos. Debe definir el mapeo de orígenes de eventos, que es la forma de identificar los
eventos cuyo seguimiento se desea realizar y la función de Lambda que se debe invocar.

A continuación se muestran ejemplos introductorios de orígenes de eventos y del funcionamiento de la

experiencia integral.

Ejemplo 1: Amazon S3 envía eventos e invoca una

función de Lambda
Amazon S3 puede publicar eventos de diferentes tipos, como, por ejemplo, los eventos de objetos PUT,
POST, COPY y DELETE en un bucket. Mediante la característica de notificaciones de los buckets, puede
configurar un mapeo de origen de eventos que indique a Amazon S3 que invoque una función de Lambda
cuando se produzca un tipo concreto de evento, tal como se muestra en la siguiente ilustración.

147
 AWS Lambda Guía para desarrolladores
Ejemplo 2: AWS Lambda obtiene los eventos desde
un flujo de Kinesis e invoca una función de Lambda

El diagrama ilustra la siguiente secuencia:

1. El usuario crea un objeto en un bucket.

2. Amazon S3 detecta el evento de creación de objeto.
3. Amazon S3 invoca la función de Lambda utilizando los permisos proporcionados por el rol de
ejecución (p. 32).
4. AWS Lambda ejecuta la función de Lambda, especificando el evento como parámetro.

Puede configurar Amazon S3 para que invoque la función como una acción de notificación del bucket. Para
conceder a Amazon S3 permisos para invocar la función, actualice la política basada en recursos (p. 36)
de la función.

Ejemplo 2: AWS Lambda obtiene los eventos desde

un flujo de Kinesis e invoca una función de Lambda
Para los orígenes de eventos basados en sondeos, AWS Lambda sondea el origen y, a continuación,
invoca la función de Lambda cuando se detectan registros en ese origen.

• CreateEventSourceMapping (p. 460)

• UpdateEventSourceMapping (p. 592)

En el siguiente diagrama se muestra cómo una aplicación personalizada escribe registros en un flujo de
Kinesis.

148
 AWS Lambda Guía para desarrolladores
Prácticas recomendadas

El diagrama ilustra la siguiente secuencia:

1. La aplicación personalizada escribe registros en un flujo de Kinesis.

2. AWS Lambda sondea constantemente el flujo, e invoca la función de Lambda cuando el servicio detecta
registros nuevos en el flujo. AWS Lambda sabe cuál es el flujo que debe sondear y la función de
Lambda que debe invocar basándose en el mapeo de origen de eventos que se ha creado en Lambda.
3. La función de Lambda se invoca con el evento entrante.

Cuando trabaje con orígenes de eventos basados en flujos, debe crear mapeos de orígenes de eventos en
AWS Lambda. Lambda lee los elementos del flujo e invoca la función de forma síncrona. No es necesario
que conceda a Lambda permiso para invocar la función, pero esta necesita permiso para leer los datos del
flujo.

Prácticas recomendadas para trabajar con

funciones de AWS Lambda
A continuación se indican las prácticas recomendadas para utilizar AWS Lambda:

Temas
• Código de la función (p. 149)
• Función de configuración (p. 150)
• Alarmas y métricas (p. 151)
• Invocaciones con eventos de flujo (p. 151)

Código de la función
• Separe el controlador de Lambda de la lógica del núcleo. Esto le permite probar las distintas unidades de
la función con mayor facilidad. En [Link], podría tener este aspecto:

[Link] = function(event, context, callback) {

var foo = [Link];
var bar = [Link];
var result = MyLambdaFunction (foo, bar);

callback(null, result);

149
 AWS Lambda Guía para desarrolladores
Función de configuración

function MyLambdaFunction (foo, bar) {

// MyLambdaFunction logic here
}

• Aproveche la reutilización de contextos de ejecución para mejorar el rendimiento de la función. Inicialice

los clientes de SDK y las conexiones de base de datos fuera del controlador de funciones y almacene
localmente en caché los recursos estáticos en el directorio /tmp. Las invocaciones posteriores
procesadas por la misma instancia de su función pueden reutilizar estos recursos. Esto ahorra tiempo de
ejecución y costos.

Para evitar posibles filtraciones de datos entre las invocaciones, no utilice el contexto de ejecución para
almacenar datos de usuario, eventos u otra información con implicaciones de seguridad. Si su función se
basa en un estado mutable que no se puede almacenar en la memoria dentro del controlador, considere
crear una función independiente o versiones independientes de una función para cada usuario.
• Utilice variables de entorno (p. 54) para pasar parámetros operativos a su función. Por ejemplo, si está
escribiendo en un bucket de Amazon S3, en lugar de codificar de forma rígida el nombre del bucket,
configúrelo como una variable de entorno.
• Controle las dependencias del paquete de implementación de la función. El entorno de ejecución
de AWS Lambda contiene una serie de bibliotecas, como el SDK de AWS para los tiempos de
ejecución de [Link] y Python (puede encontrar una lista completa aquí: Tiempos de ejecución de
AWS Lambda. (p. 118)). Para disponer del conjunto más reciente de características y actualizaciones
de seguridad, Lambda actualizará periódicamente estas bibliotecas. Estas actualizaciones pueden
introducir cambios sutiles en el comportamiento de la función de Lambda. Para disponer de un control
total de las dependencias que utiliza la función, empaquete todas las dependencias con el paquete de
implementación.
• Minimice el tamaño del paquete de implementación de acuerdo con las necesidades de su tiempo de
ejecución. Esto reducirá la cantidad de tiempo que tarda el paquete de implementación en descargarse
y desempaquetarse antes de la invocación. En las funciones creadas en Java o .NET Core, evite cargar
toda la biblioteca del SDK de AWS como parte del paquete de implementación. En lugar de ello, cree
dependencias selectivas de los módulos que seleccionen los componentes del SDK que necesita (por
ejemplo, DynamoDB, módulos del SDK de Amazon S3 y bibliotecas básicas de Lambda).
• Reduzca el tiempo que tarda Lambda en desempaquetar los paquetes de implementación escritos
en Java colocando los archivos .jar de dependencias en un directorio /lib independiente. Esto es
más rápido que colocar todo el código de la función en un único archivo jar con un gran número de
archivos .class. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).
• Minimice la complejidad de las dependencias. Son preferibles los marcos de trabajo más sencillos, ya
que se cargan rápidamente al arrancar el contexto de ejecución (p. 120). Por ejemplo, es preferible
utilizar los marcos de trabajo de inserción de dependencias (IoC) de Java más sencillos, como Dagger o
Guice, que los más complejos, como Spring Framework.
• Evite utilizar código recursivo en la función de Lambda que haga que esta llame a sí misma
automáticamente hasta que se cumplan ciertos criterios arbitrarios. Esto podría producir un volumen no
intencionado de invocaciones de la función y costos elevados. Si lo hace accidentalmente, establezca el
límite de ejecuciones simultáneas de la función en 0 para limitar inmediatamente todas las invocaciones
a la función, mientras actualiza el código.

Función de configuración
• La prueba de desempeño de la función de Lambda es una parte crucial a la hora de garantizar la
elección de la configuración de memoria óptima. Cualquier aumento del tamaño de la memoria causa
un aumento equivalente de la CPU disponible para la función. El uso de la memoria de la función se
determina por invocación y puede visualizarse en AWS CloudWatch Logs. En cada invocación se genera
una entrada REPORT:, tal como se muestra a continuación:

150
 AWS Lambda Guía para desarrolladores
Alarmas y métricas

REPORT RequestId: 3604209a-e9a3-11e6-939a-754dd98c7be3 Duration: 12.34 ms Billed

Duration: 100 ms Memory Size: 128 MB Max Memory Used: 18 MB

Analice el campo Max Memory Used: para determinar si la función necesita más memoria o si ha
aprovisionado en exceso el tamaño de la memoria para la función.
• Realice una prueba de carga de la función de Lambda para determinar un valor de tiempo de espera
óptimo. Es importante analizar cuánto tiempo se ejecuta la función para determinar más fácilmente
los posibles problemas con un servicio de dependencias que puedan aumentar la concurrencia de la
función más allá de lo esperado. Esto es especialmente importante cuando la función de Lambda realiza
llamadas de red a recursos que pueden no gestionar el escalado de Lambda.
• Utilice los permisos más restrictivos al establecer las políticas de IAM. Conozca los recursos y las
operaciones que la función de Lambda necesita, y limite el rol de ejecución a estos permisos. Para
obtener más información, consulte Permisos de AWS Lambda (p. 32).
• Familiarícese con los Límites de AWS Lambda (p. 30). A menudo, el tamaño de carga, los descriptores
de archivo y el espacio de /tmp se pasan por alto a la hora de determinar los límites de recursos del
tiempo de ejecución.
• Elimine las funciones de Lambda que ya no utilice. Al hacerlo, las funciones no utilizadas no contarán
innecesariamente para el límite de tamaño del paquete de implementación.
• Si usa Amazon Simple Queue Service como origen de eventos, asegúrese de que el valor del tiempo de
ejecución esperado de la función no supere el valor de tiempo de espera de visibilidad en la cola. Esto
se aplica tanto a CreateFunction (p. 466) como a UpdateFunctionConfiguration (p. 605).
• En el caso de CreateFunction, AWS Lambda no realizará el proceso de creación de función.
• En el caso de UpdateFunctionConfiguration, podría dar lugar a invocaciones duplicadas de la función.

Alarmas y métricas
• Utilice Trabajar con métricas de función de AWS Lambda (p. 400) y Alarmas de CloudWatch en lugar
de crear o actualizar una métrica desde dentro de la función de código de Lambda. Es una forma mucho
más eficaz de realizar el seguimiento del estado de las funciones de Lambda, y le permitirá identificar los
problemas al comienzo del proceso de desarrollo. Por ejemplo, puede configurar una alarma de acuerdo
con la duración esperada del tiempo de ejecución de la función Lambda para solucionar los cuellos de
botella o las latencias atribuibles al código de la función.
• Utilice la biblioteca de registro y las dimensiones y métricas de AWS Lambda para detectar los errores
de las aplicaciones (por ejemplo, ERR, ERROR, WARNING, etc.)

Invocaciones con eventos de flujo

• Pruebe con diferentes tamaños de lote y de registro para que la frecuencia de sondeo de cada
origen de eventos se ajuste a la velocidad con la que la función es capaz de completar su tarea.
BatchSize (p. 461) controla el número máximo de registros que se pueden enviar a la función en
cada invocación. A menudo, un tamaño de lote mayor puede absorber de forma más eficiente el tráfico
adicional asociado a un conjunto de registros mayor, mejorando el desempeño.

De forma predeterminada, Lambda llama a su función en cuanto los registros están disponibles en el
flujo. Si el lote que lee desde el flujo solo tiene un registro, Lambda solo envía un registro a la función.
Para evitar invocar a la función con un número de registros pequeño, puede indicar al origen del evento
que almacene en búfer registros durante hasta 5 minutos configurando una ventana de lote. Antes de
invocar a la función, Lambda sigue leyendo registros desde el flujo hasta que haya recopilado un lote
completo o hasta que caduca la ventana de lote.

151
 AWS Lambda Guía para desarrolladores
Invocaciones con eventos de flujo

• Aumente el desempeño del procesamiento de flujos de Kinesis añadiendo fragmentos. Un flujo de

Kinesis se compone de uno o varios fragmentos. Lambda sondeará cada fragmento que tenga como
máximo una invocación simultánea. Por ejemplo, si el flujo tiene 100 fragmentos activos, habrá como
máximo 100 invocaciones a la función de Lambda ejecutándose simultáneamente. Al aumentar el
número de fragmentos, aumentará directamente el número máximo de invocaciones simultáneas a
la función de Lambda, y también puede incrementarse el desempeño del procesamiento de flujos de
Kinesis. Si aumenta el número de fragmentos de un flujo de Kinesis, asegúrese de que ha elegido
una buena clave de partición (consulte Claves de partición) para los datos, de forma que los registros
relacionados acaben en los mismos fragmentos y los datos estén bien distribuidos.
• Utilice Amazon CloudWatch en IteratorAge para determinar si el flujo de Kinesis se está procesando. Por
ejemplo, configure una alarma de CloudWatch con un valor máximo de 30000 (30 segundos).

152
 AWS Lambda Guía para desarrolladores

Uso de AWS Lambda con otros

servicios
AWS Lambda se integra con otros servicios de AWS para invocar funciones. Puede configurar
desencadenadores para invocar una función en respuesta a los eventos del ciclo de vida de los
recursos, responder a solicitudes HTTP entrantes, consumir eventos de una cola o realizar ejecuciones
programadas (p. 185).

Cada servicio que se integra con Lambda envía datos a la función como un evento con formato JSON.
La estructura del documento de evento es diferente para cada tipo de evento y contiene datos sobre el
recurso o la solicitud que activó la función. Los tiempos de ejecución de Lambda convierten el evento en un
objeto y se lo pasan a la función.

En el siguiente ejemplo, se muestra un evento de prueba procedente de un Balanceador de carga de

aplicaciones (p. 155) que representa una solicitud GET para /lambda?query=1234ABCD.

Example Evento procedente de un Balanceador de carga de aplicaciones

{
"requestContext": {
"elb": {
"targetGroupArn": "arn:aws:elasticloadbalancing:us-
east-2:123456789012:targetgroup/lambda-279XGJDqGZ5rsrHC2Fjr/49e9d65c45c6791a"
}
},
"httpMethod": "GET",
"path": "/lambda",
"queryStringParameters": {
"query": "1234ABCD"
},
"headers": {
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/
apng,*/*;q=0.8",
"accept-encoding": "gzip",
"accept-language": "en-US,en;q=0.9",
"connection": "keep-alive",
"host": "[Link]",
"upgrade-insecure-requests": "1",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/71.0.3578.98 Safari/537.36",
"x-amzn-trace-id": "Root=1-5c536348-3d683b8b04734faae651f476",
"x-forwarded-for": "[Link]",
"x-forwarded-port": "80",
"x-forwarded-proto": "http",
"x-imforwards": "20"
},
"body": "",
"isBase64Encoded": false
}

Note
El runtime de Lambda convierte el documento de evento en un objeto y se lo pasa al controlador
de la función (p. 17). Para los lenguajes compilados, Lambda proporciona las definiciones de los
tipos de eventos en una biblioteca. Consulte los temas siguientes para obtener más información.

• Creación de funciones de Lambda con Java (p. 328)

153
 AWS Lambda Guía para desarrolladores

• Creación de funciones de Lambda con Go (p. 359)

• Creación de funciones de Lambda con C# (p. 372)
• Creación de funciones de Lambda con PowerShell (p. 390)

En el caso de los servicios que generan una cola o un flujo de datos, debe crear un mapeo de origen de
eventos (p. 97) en Lambda y conceder a Lambda permiso para tener acceso al otro servicio en el rol de
ejecución (p. 32). Lambda lee los datos desde el otro servicio, crea un evento e invoca la función.

Servicios cuyos eventos lee Lambda

• Amazon Kinesis (p. 233)

• Amazon DynamoDB (p. 204)
• Amazon Simple Queue Service (p. 277)

Los demás servicios invocan la función directamente. Debe conceder al otro servicio permiso en la política
basada en recursos (p. 36) de la función y configurar el otro servicio para que genere eventos e invoque
la función. En función del servicio, la invocación puede ser síncrona o asíncrona. Para la invocación
síncrona, el otro servicio espera la respuesta de la función y puede realizar reintentos si se producen
errores (p. 107).

Servicios que invocan funciones de Lambda de forma síncrona

• Elastic Load Balancing (Balanceador de carga de aplicaciones) (p. 155)

• Amazon Cognito (p. 203)
• Amazon Lex (p. 249)
• Amazon Alexa (p. 156)
• Amazon API Gateway (p. 157)
• Amazon CloudFront (Lambda@Edge) (p. 193)
• Amazon Kinesis Data Firehose (p. 248)
• AWS Step Functions
• Lote de Amazon Simple Storage Service (p. 268)

Para la invocación asíncrona, Lambda coloca el evento en la cola antes de pasárselo a la función. El otro
servicio obtiene una respuesta de operación correcta en cuanto el evento se pone en cola y no está al
tanto de lo que ocurre después. Si se produce un error, Lambda gestiona los reintentos (p. 107) y puede
enviar los eventos con errores a la cola de mensajes fallidos (p. 95) que se haya configurado.

Servicios que invocan funciones de Lambda de forma asíncrona

• Amazon Simple Storage Service (p. 254)

• Amazon Simple Notification Service (p. 271)
• Amazon Simple Email Service (p. 270)
• AWS CloudFormation (p. 191)
• Amazon CloudWatch Logs (p. 190)
• Amazon CloudWatch Events (p. 185)
• AWS CodeCommit (p. 194)
• AWS Config (p. 203)
• AWS IoT (p. 231)
• Eventos de AWS IoT (p. 232)
• AWS CodePipeline (p. 195)

154
 AWS Lambda Guía para desarrolladores
Balanceador de carga de aplicaciones

Consulte los temas de este capítulo para obtener más información sobre cada servicio y eventos de
ejemplo que puede utilizar para probar la función.

Uso de AWS Lambda con un Balanceador de carga

de aplicaciones
Puede utilizar funciones de Lambda para procesar solicitudes desde un Balanceador de carga de
aplicaciones. Elastic Load Balancing admite funciones de Lambda como destinos de un Balanceador de
carga de aplicaciones. Utilice reglas de balanceador de carga para direccionar solicitudes HTTP a una
función según la ruta o los valores de encabezado. Procese la solicitud y devuelva una respuesta HTTP
desde de su función de Lambda.

Elastic Load Balancing invoca la función de Lambda de forma sincrónica con un evento que contiene el
cuerpo de la solicitud y metadatos.

Example Evento de solicitud de Balanceador de carga de aplicaciones

{
"requestContext": {
"elb": {
"targetGroupArn": "arn:aws:elasticloadbalancing:us-
east-2:123456789012:targetgroup/lambda-279XGJDqGZ5rsrHC2Fjr/49e9d65c45c6791a"
}
},
"httpMethod": "GET",
"path": "/lambda",
"queryStringParameters": {
"query": "1234ABCD"
},
"headers": {
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/
apng,*/*;q=0.8",
"accept-encoding": "gzip",
"accept-language": "en-US,en;q=0.9",
"connection": "keep-alive",
"host": "[Link]",
"upgrade-insecure-requests": "1",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/71.0.3578.98 Safari/537.36",
"x-amzn-trace-id": "Root=1-5c536348-3d683b8b04734faae651f476",
"x-forwarded-for": "[Link]",
"x-forwarded-port": "80",
"x-forwarded-proto": "http",
"x-imforwards": "20"
},
"body": "",
"isBase64Encoded": false
}

Su función procesa el evento y devuelve un documento de respuesta al balanceador de carga en JSON.

Elastic Load Balancing convierte el documento en una respuesta HTTP de éxito o error y lo devuelve al
usuario.

Example Formato del documento de respuesta

{
"statusCode": 200,

155
 AWS Lambda Guía para desarrolladores
Alexa

"statusDescription": "200 OK",

"isBase64Encoded": False,
"headers": {
"Content-Type": "text/html"
},
"body": "<h1>Hello from Lambda!</h1>"
}

Para configurar Balanceador de carga de aplicaciones como desencadenador de funciones, conceda

a Elastic Load Balancing permiso para ejecutar la función, cree un grupo de destino que direccione las
solicitudes a la función y añada una regla al balanceador de carga para enviar las solicitudes al grupo de
destino.

Utilice el comando add-permission para añadir una instrucción de permiso a la política basada en
recursos de la función.

$ aws lambda add-permission --function-name alb-function \

--statement-id load-balancer --action "lambda:InvokeFunction" \
--principal [Link]
{
"Statement": "{\"Sid\":\"load-balancer\",\"Effect\":\"Allow\",\"Principal\":{\"Service
\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-west-2:123456789012:function:alb-function\"}"
}

Para ver instrucciones sobre cómo configurar el agente de escucha de Balanceador de carga de
aplicaciones, consulte la sección sobre funciones de Lambda como destino en la Guía del usuario de
Application Load Balancers.

Uso de AWS Lambda con Alexa

Puede utilizar funciones de Lambda para crear servicios que aporten nuevas habilidades a Alexa,
el asistente de voz de Amazon Echo. Alexa Skills Kit proporciona las API, las herramientas y la
documentación para crear estas nuevas habilidades, basadas en sus propios servicios que se ejecutan
como funciones de Lambda. Los usuarios de Amazon Echo pueden obtener acceso a estas nuevas
habilidades haciendo preguntas a Alexa o realizando solicitudes.

El Alexa Skills Kit está disponible en GitHub.

• Alexa Skills Kit SDK para [Link]

• Alexa Skills Kit SDK para Java

Example Evento de Alexa Smart Home

{
"header": {
"payloadVersion": "1",
"namespace": "Control",
"name": "SwitchOnOffRequest"
},
"payload": {
"switchControlAction": "TURN_ON",
"appliance": {
"additionalApplianceDetails": {
"key2": "value2",
"key1": "value1"
},

156
 AWS Lambda Guía para desarrolladores
API Gateway

"applianceId": "sampleId"
},
"accessToken": "sampleAccessToken"
}
}

Para obtener más información, consulte la página de introducción a Alexa Skills Kit.

Uso de AWS Lambda con Amazon API Gateway

Puede crear una API web con un punto de enlace HTTP para la función Lambda utilizando Amazon
API Gateway. API Gateway dispone de herramientas para crear y documentar API web que enrutan
solicitudes HTTP a funciones Lambda. Puede proteger el acceso a la API con controles de autenticación y
autorización. Las API pueden atender el tráfico a través de Internet o estar accesibles exclusivamente en la
VPC.

Para agregar un punto de enlace público a la función Lambda

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add trigger (Añadir disparador).
4. Elija API Gateway (Gateway de API).
5. En API, elija Create an API (Crear una API).
6. En Security (Seguridad), elija Open (Abrir).
7. Elija Add (Añadir).

Con el desencadenador de API Gateway (Gateway de API) seleccionado en el diseñador, elija el punto de
enlace que va a invocar la función con API Gateway.

Las API de API Gateway se componen de etapas, recursos, métodos e integraciones. La etapa y el
recurso determinan la ruta del punto de enlace:

Formato de la ruta de las API

• /prod/: etapa prod y recurso raíz.

• /prod/user: etapa prod y recurso user.
• /dev/{proxy+}: cualquier ruta de la etapa dev.

157
 AWS Lambda Guía para desarrolladores
API Gateway

• /: (API HTTP) etapa predeterminada y recurso raíz.

La integración de Lambda asigna una combinación de ruta y método HTTP a una función Lambda. Puede
configurar API Gateway para pasar el cuerpo de la solicitud HTTP tal cual (integración personalizada) o
para encapsular el cuerpo de la solicitud en un documento que incluya toda la información de la solicitud,
incluidos los encabezados, los recursos, la ruta y el método.

Amazon API Gateway invoca la función sincrónicamente (p. 88) con un evento que contiene una
representación JSON de la solicitud HTTP. En las integraciones personalizadas, el evento es el cuerpo de
la solicitud. En las integraciones de proxy, el evento tiene una estructura definida. En el siguiente ejemplo,
se muestra un evento proxy procedente de una API REST de API Gateway.

Example [Link]: evento de proxy de API Gateway (REST API)

{
"resource": "/",
"path": "/",
"httpMethod": "GET",
"requestContext": {
"resourcePath": "/",
"httpMethod": "GET",
"path": "/Prod/",
...
},
"headers": {
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/
apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
"accept-encoding": "gzip, deflate, br",
"Host": "[Link]",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML,
like Gecko) Chrome/80.0.3987.132 Safari/537.36",
"X-Amzn-Trace-Id": "Root=1-5e66d96f-7491f09xmpl79d18acf3d050",
...
},
"multiValueHeaders": {
"accept": [
"text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/
*;q=0.8,application/signed-exchange;v=b3;q=0.9"
],
"accept-encoding": [
"gzip, deflate, br"
],
...
},
"queryStringParameters": null,
"multiValueQueryStringParameters": null,
"pathParameters": null,
"stageVariables": null,
"body": null,
"isBase64Encoded": false
}

En este ejemplo, se muestra un evento de una solicitud GET en la ruta raíz de la etapa Prod de una API
REST. La forma y el contenido del evento varían según el tipo de API (p. 162) y la configuración.

API Gateway espera una respuesta de la función y transmite el resultado a la persona que llama. En las
integraciones personalizadas, debe definir una respuesta de integración y una respuesta de método para
convertir la salida de la función en una respuesta HTTP. En las integraciones de proxy, la función debe
responder con una representación de la respuesta en un formato específico.

En el ejemplo siguiente, se muestra un objeto response de una función [Link]. El objeto response
representa una respuesta HTTP correcta que contiene un documento JSON.

158
 AWS Lambda Guía para desarrolladores
Permisos

Example [Link] –: objeto Response de integración de proxy ([Link])

var response = {
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
"isBase64Encoded": false,
"multiValueHeaders": {
"X-Custom-Header": ["My value", "My other value"],
},
"body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}"
}

El tiempo de ejecución de Lambda serializa el objeto response en un archivo JSON y lo envía a la API. La
API analiza la respuesta y la utiliza para crear una respuesta HTTP, que luego envía al cliente que realizó
la solicitud original.

Example Respuesta HTTP

< HTTP/1.1 200 OK

< Content-Type: application/json
< Content-Length: 55
< Connection: keep-alive
< x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356
< X-Custom-Header: My value
< X-Custom-Header: My other value
< X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036
<
{
"TotalCodeSize": 104330022,
"FunctionCount": 26
}

Los recursos de la API definen uno o varios métodos, como GET o POST. Los métodos tienen una
integración que enruta las solicitudes a una función Lambda o a otro tipo de integración. Puede definir cada
recurso y cada método de manera individual, o utilizar tipos de recursos y métodos especiales para que
coincidan con todas las solicitudes que se ajustan a un patrón. Un recurso proxy captura todas las rutas
que hay debajo de un recurso. El método ANY captura todos los métodos HTTP.

Secciones
• Permisos (p. 159)
• Administración de errores con una API de API Gateway (p. 161)
• Elegir un tipo de API (p. 162)
• Aplicaciones de ejemplo (p. 163)
• Tutorial: uso de AWS Lambda con Amazon API Gateway (p. 164)
• Código de función de muestra (p. 172)
• Creación de un microservicio sencillo utilizando Lambda y API Gateway (p. 175)
• Plantilla de AWS SAM para una aplicación de API Gateway (p. 176)

Permisos
Amazon API Gateway necesita permiso para invocar la función desde la política basada en
recursos (p. 36) de la función. Puede conceder permiso de invocación a toda una API o conceder acceso
limitado a una etapa, un recurso o un método.

159
 AWS Lambda Guía para desarrolladores
Permisos

Cuando agrega una API a la función utilizando la consola de Lambda, la consola de API Gateway o una
plantilla de AWS SAM, la política basada en recursos de la función se actualiza automáticamente. En
el ejemplo siguiente, se muestra la política de una función con una instrucción agregada mediante una
plantilla de AWS SAM.

Example Política de funciones

{
"Version": "2012-10-17",
"Id": "default",
"Statement": [
{
"Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F",
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:123456789012:function:nodejs-apig-
function-1G3MXMPLXVXYI",
"Condition": {
"ArnLike": {
"AWS:SourceArn": "arn:aws:execute-api:us-east-2:123456789012:ktyvxmpls1/*/GET/"
}
}
}
]
}

Confirme la política de la función (p. 36) en la pestaña Permissions (Permisos) de la consola de Lambda.

Puede administrar manualmente los permisos de las políticas de funciones con las siguientes operaciones
de API:

• AddPermission (p. 452)

• RemovePermission (p. 582)
• GetPolicy (p. 522)

Para conceder permiso de invocación a una API existente, utilice el comando add-permission.

$ aws lambda add-permission --function-name my-function \

--statement-id apigateway-get --action lambda:InvokeFunction \
--principal [Link] \
--source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/"
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike
\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET
\"}}}"
}

Note

Si la función y la API se encuentran en regiones diferentes, el identificador de región en el ARN

del origen debe coincidir con la región de la función, no la región de la API. Cuando API Gateway
invoca una función, utiliza el ARN de un recurso que se basa en el ARN de la API, pero que se ha
modificado para que coincida con la región de la función.

160
 AWS Lambda Guía para desarrolladores
Administración de errores con una API de API Gateway

El ARN de origen de este ejemplo concede permiso a una integración del método GET del recurso raíz
en la etapa predeterminada de una API, con el ID mnh1xmpli7. Puede utilizar un asterisco en el ARN de
origen para conceder permisos a varias etapas, métodos o recursos.

Patrones de recursos

• mnh1xmpli7/*/GET/*: método GET de todos los recursos en todas las etapas.

• mnh1xmpli7/prod/ANY/user: método ANY del recurso user en la etapa prod.
• mnh1xmpli7/*/*/*: cualquier método de todos los recursos en todas las etapas.

Para obtener información detallada acerca de cómo ver la política y quitar instrucciones, consulte Limpieza
de políticas basadas en recursos (p. 40).

Administración de errores con una API de API

Gateway
API Gateway trata todos los errores de las invocaciones y las funciones como errores internos. Si la API de
Lambda rechaza la solicitud de invocación, API Gateway devuelve un código de error 500. Si la función se
ejecuta pero devuelve un error o devuelve una respuesta con un formato incorrecto, API Gateway muestra
un error 502. En ambos casos, el cuerpo de la respuesta de API Gateway es {"message": "Internal
server error"}.

En el ejemplo siguiente, se muestra un mapa de seguimiento de X-Ray de una solicitud que generó un
error de función y un error 502 de API Gateway. El cliente recibirá el mensaje de error genérico.

Para personalizar la respuesta del error, debe detectar errores en el código y elaborar una respuesta en el
formato que desee.

Example [Link]: aplicar formato a un error

var formatError = function(error){

var response = {
"statusCode": [Link],
"headers": {
"Content-Type": "text/plain",
"x-amzn-ErrorType": [Link]
},
"isBase64Encoded": false,
"body": [Link] + ": " + [Link]
}
return response
}

API Gateway convierte esta respuesta en un error HTTP con un código de estado y un cuerpo
personalizados. En el mapa de seguimiento, el nodo de la función es verde porque el error se administró
correctamente.

161
 AWS Lambda Guía para desarrolladores
Elegir un tipo de API

Elegir un tipo de API

API Gateway admite tres tipos de API que invocan funciones Lambda:

• API HTTP: API RESTful ligera de baja latencia.

• API REST: API RESTful personalizable con gran variedad de características.
• API WebSocket : API web que mantiene conexiones persistentes con clientes para una comunicación
dúplex completa.

Las API HTTP y REST son API RESTful que procesan solicitudes HTTP y devuelven respuestas. Las
API HTTP son más recientes y se construyen con la API de la versión 2 de API Gateway. Las siguientes
características son nuevas en las API HTTP:

Características de las API HTTP

• Implementaciones automáticas: cuando se modifican rutas o integraciones, los cambios se implementan

automáticamente en etapas que tienen habilitada la implementación automática.
• Etapa predeterminada: puede crear una etapa predeterminada ($default) para atender las solicitudes
en la ruta raíz de la URL de la API. En las etapas con nombre asignado, debe incluir el nombre de la
etapa al principio de la ruta.
• Configuración CORS: puede configurar la API para agregar encabezados CORS a las respuestas
salientes, en lugar de agregarlos manualmente en el código de función.

Las API REST son las API RESTful clásicas que API Gateway admite desde su lanzamiento. En la
actualidad, las API REST tienen más características de personalización, integración y administración.

Características de las API REST

• Tipos de integración: las API REST son compatibles con las integraciones de Lambda personalizadas.
Con una integración personalizada, puede enviar solo el cuerpo de la solicitud a la función o aplicar una
plantilla de transformación al cuerpo de la solicitud antes de enviarla a la función.
• Control de acceso: las API REST admiten más opciones de autenticación y autorización.
• Monitoreo y seguimiento: la API REST admiten el seguimiento de AWS X-Ray y otras opciones de
registro.

Para ver una comparativa detallada, consulte Elección entre HTTP API y REST API en la Guía para
desarrolladores de API Gateway.

Las API de WebSocket también usan la API de la versión 2 de API Gateway y admiten un conjunto de
características similares. Utilice una API de WebSocket para las aplicaciones que se benefician de una
conexión persistente entre el cliente y la API. Las API de WebSocket proporcionan comunicación dúplex
completa, lo que significa que tanto el cliente como la API pueden enviar mensajes continuamente sin
esperar una respuesta.

162
 AWS Lambda Guía para desarrolladores
Aplicaciones de ejemplo

Las API de WebSocket y las API HTTP pueden utilizar un formato de evento simplificado (versión 2.0). En
el ejemplo siguiente, se muestra el evento de una API HTTP.

Example [Link]: evento de proxy de API Gateway (API HTTP)

{
"version": "2.0",
"routeKey": "ANY /nodejs-apig-function-1G3XMPLZXVXYI",
"rawPath": "/default/nodejs-apig-function-1G3XMPLZXVXYI",
"rawQueryString": "",
"cookies": [
"s_fid=7AABXMPL1AFD9BBF-0643XMPL09956DE2",
"regStatus=pre-register"
],
"headers": {
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/
apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9",
"accept-encoding": "gzip, deflate, br",
...
},
"requestContext": {
"accountId": "123456789012",
"apiId": "r3pmxmplak",
"domainName": "[Link]",
"domainPrefix": "r3pmxmplak",
"http": {
"method": "GET",
"path": "/default/nodejs-apig-function-1G3XMPLZXVXYI",
"protocol": "HTTP/1.1",
"sourceIp": "[Link]",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36"
},
"routeKey": "ANY /nodejs-apig-function-1G3XMPLZXVXYI",
"stage": "default",
"time": "10/Mar/2020:05:16:23 +0000",
"timeEpoch": 1583817383220
},
"isBase64Encoded": true
}

Para obtener más información, consulte este artículo sobre las integraciones de AWS Lambda en la Guía
para desarrolladores de API Gateway.

Aplicaciones de ejemplo
El repositorio de GitHub para esta guía incluye la siguiente aplicación de ejemplo de API Gateway.

• API Gateway con [Link]: función con una plantilla de AWS SAM que crea una API REST que tiene el
seguimiento de AWS X-Ray habilitado. Incluye scripts para implementar, invocar la función, probar la API
y limpiar.

Lambda también dispone de proyectos (p. 27) y plantillas (p. 28) que puede utilizar para crear una
aplicación de API Gateway en la consola de Lambda.

163
 AWS Lambda Guía para desarrolladores
Tutorial

Tutorial: uso de AWS Lambda con Amazon API

Gateway
En este ejemplo se crea una API sencilla utilizando Amazon API Gateway. Una instancia de
Amazon API Gateway es un conjunto de recursos y métodos. En este tutorial, se crea un recurso
(DynamoDBManager) y se define un método (POST) en él. El método está respaldado por una función de
Lambda (LambdaFunctionOverHttps). Es decir, cuando se llama al API a través de un punto de enlace
HTTPS, Amazon API Gateway invoca la función de Lambda.

El método POST del recurso DynamoDBManager admite las siguientes operaciones de DynamoDB:

• Crear, actualizar y eliminar un elemento.

• Leer un elemento.
• Examinar un elemento.
• Otras operaciones (echo, ping), no relacionadas con DynamoDB, que puede utilizar para las pruebas.

La carga de solicitud que se envía en la solicitud POST identifica la operación de DynamoDB y proporciona
los datos necesarios. Por ejemplo:

• A continuación se muestra una carga de solicitud de ejemplo para una operación create item de
DynamoDB:

{
"operation": "create",
"tableName": "lambda-apigateway",
"payload": {
"Item": {
"id": "1",
"name": "Bob"
}
}
}

• A continuación se muestra una carga de solicitud de ejemplo para una operación read item de
DynamoDB:

{
"operation": "read",
"tableName": "lambda-apigateway",
"payload": {
"Key": {
"id": "1"
}
}
}

• A continuación se muestra una carga de solicitud de ejemplo para una operación echo. Envía una
solicitud HTTP POST al punto de enlace usando los datos siguientes en el cuerpo de la solicitud.

{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}

164
 AWS Lambda Guía para desarrolladores
Tutorial

Note

API Gateway ofrece capacidades avanzadas, como por ejemplo:

• Transferencia de la solicitud completa: una función de Lambda puede recibir la solicitud HTTP
completa (en lugar de solo el cuerpo de la solicitud) y establecer la respuesta HTTP (en lugar
de solo el cuerpo de la respuesta) utilizando el tipo de integración AWS_PROXY.
• Métodos catch-all: mapea todos los métodos de un recurso de la API a una sola función de
Lambda con un único mapeo, utilizando el método catch-all ANY.
• Recursos catch-all: mapea todas las subrutas de un recurso a una función de Lambda sin
necesidad de realizar ninguna configuración adicional, mediante el nuevo parámetro de ruta
({proxy+}).

Para obtener más información acerca de estas características de API Gateway, consulte
Configuración de la integración del proxy para un recurso de proxy.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza): Lambda.

• Role name (Nombre de rol): lambda-apigateway-role.
• Permisos – Política personalizada con permiso para DynamoDB y CloudWatch Logs.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Stmt1428341300017",
"Action": [

165
 AWS Lambda Guía para desarrolladores
Tutorial

"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Query",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Effect": "Allow",
"Resource": "*"
},
{
"Sid": "",
"Resource": "*",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents"
],
"Effect": "Allow"
}
]
}

La política personalizada tiene los permisos que la función necesita para escribir datos a DynamoDB y
subir registros. Anote el nombre de recurso de Amazon (ARN) del rol para uso posterior.

Creación de la función
A continuación se muestra código de ejemplo que recibe un evento de API Gateway como entrada y
procesa los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los
eventos de entrada en CloudWatch Logs.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 172).

Example [Link]

[Link]('Loading function');

var AWS = require('aws-sdk');

var dynamo = new [Link]();

/**
* Provide an event that contains the following keys:
*
* - operation: one of the operations in the switch statement below
* - tableName: required for operations that interact with DynamoDB
* - payload: a parameter to pass to the operation being performed
*/
[Link] = function(event, context, callback) {
//[Link]('Received event:', [Link](event, null, 2));

var operation = [Link];

if ([Link]) {
[Link] = [Link];
}

switch (operation) {
case 'create':
[Link]([Link], callback);

166
 AWS Lambda Guía para desarrolladores
Tutorial

break;
case 'read':
[Link]([Link], callback);
break;
case 'update':
[Link]([Link], callback);
break;
case 'delete':
[Link]([Link], callback);
break;
case 'list':
[Link]([Link], callback);
break;
case 'echo':
callback(null, "Success");
break;
case 'ping':
callback(null, "pong");
break;
default:
callback('Unknown operation: ${operation}');
}
};

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name LambdaFunctionOverHttps \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/service-role/lambda-apigateway-role

Pruebe la función Lambda.

Invoque la función de forma manual utilizando los datos del evento de muestra. Recomendamos que
invoque la función utilizando la consola, ya que la interfaz de usuario de la consola proporciona una
interfaz fácil de utilizar para examinar los resultados de la ejecución, incluido el resumen de ejecución,
los registros escritos por el código y los resultados devueltos por la función (dado que la consola
siempre realiza una ejecución síncrona, invoca la función de Lambda utilizando el tipo de invocación
RequestResponse).

Para probar la función de Lambda

1. Copie el siguiente JSON en un archivo y guárdelo como [Link].

{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}

2. Ejecute el siguiente comando invoke:

167
 AWS Lambda Guía para desarrolladores
Tutorial

$ aws lambda invoke --function-name LambdaFunctionOverHttps \

--payload fileb://[Link] [Link]

Creación de un Amazon API Gateway usuario de AP.

En este paso, asociará la función de Lambda a un método de la API que ha creado utilizando Amazon API
Gateway y probará la experiencia integral. Es decir, cuando se envíe una solicitud HTTPS a un método de
la HTTP, Amazon API Gateway invocará la función de Lambda.

En primer lugar, debe crear una API (DynamoDBOperations) utilizando Amazon API Gateway con un
recurso (DynamoDBManager) y un método (POST). A continuación, asociará el método POST a la función
de Lambda. Y, por último, probará la experiencia integral.

Cree el API
Ejecute el siguiente comando create-rest-api para crear la API DynamoDBOperations para este
tutorial.

$ aws apigateway create-rest-api --name DynamoDBOperations

{
"id": "bs8fqo6bp0",
"name": "DynamoDBOperations",
"createdDate": 1539803980,
"apiKeySource": "HEADER",
"endpointConfiguration": {
"types": [
"EDGE"
]
}
}

Guarde el ID de API para su uso en comandos futuros. También necesita el ID del recurso raíz de la API.
Para obtener el ID, ejecute el comando get-resources.

$ API=bs8fqo6bp0
$ aws apigateway get-resources --rest-api-id $API
{
"items": [
{
"path": "/",
"id": "e8kitthgdb"
}
]
}

En ese momento solo tiene el recurso raíz, pero añadirá más recursos en el siguiente paso.

Cree un recurso en la API

Ejecute el siguiente comando create-resource para crear un recurso (DynamoDBManager) en la API
que ha creado en la sección anterior.

$ aws apigateway create-resource --rest-api-id $API --path-part DynamoDBManager \

--parent-id e8kitthgdb
{
"path": "/DynamoDBManager",

168
 AWS Lambda Guía para desarrolladores
Tutorial

"pathPart": "DynamoDBManager",
"id": "iuig5w",
"parentId": "e8kitthgdb"
}

Anote el ID de la respuesta. Este es el ID del recurso DynamoDBManager que ha creado.

Crear un método POST en el recurso

Ejecute el siguiente comando put-method para crear un método POST en el recurso DynamoDBManager
de la API.

$ RESOURCE=iuig5w
$ aws apigateway put-method --rest-api-id $API --resource-id $RESOURCE \
--http-method POST --authorization-type NONE
{
"apiKeyRequired": false,
"httpMethod": "POST",
"authorizationType": "NONE"
}

Especificamos NONE para el parámetro --authorization-type, lo que significa que se admiten

solicitudes sin autenticar para este método. Esto está bien para las pruebas, pero en producción debe
utilizar la autenticación basada en claves o en roles.

Definición de la función de Lambda como destino para el método POST

Ejecute el siguiente comando para establecer la función de Lambda como punto de integración para el
método POST. Este es el método que invoca Amazon API Gateway cuando hace una solicitud HTTP para
el método de punto de enlace POST. Este comando y otros usan ARN que incluyen su ID de cuenta y
su región. Guarde estos en variables (encontrará su ID de cuenta en el rol ARN que usó para crear la
función).

$ REGION=us-east-2
$ ACCOUNT=123456789012
$ aws apigateway put-integration --rest-api-id $API --resource-id $RESOURCE \
--http-method POST --type AWS --integration-http-method POST \
--uri arn:aws:apigateway:$REGION:lambda:path/2015-03-31/functions/arn:aws:lambda:$REGION:
$ACCOUNT:function:LambdaFunctionOverHttps/invocations
{
"type": "AWS",
"httpMethod": "POST",
"uri": "arn:aws:apigateway:us-east-2:lambda:path/2015-03-31/functions/
arn:aws:lambda:us-east-2:123456789012:function:LambdaFunctionOverHttps/invocations",
"passthroughBehavior": "WHEN_NO_MATCH",
"timeoutInMillis": 29000,
"cacheNamespace": "iuig5w",
"cacheKeyParameters": []
}

--integration-http-method es el método que usa API Gateway para comunicarse con AWS
Lambda. --uri es identificador único para el punto de enlace al cual Amazon API Gateway puede mandar
solicitud.

Establezca el content-type de la respuesta de integración y de la respuesta del método POST en JSON

como se indica a continuación:

• Ejecute el siguiente comando para establecer la respuesta del método POST en JSON. Este es el tipo de
respuesta que devuelve el método de la API.

169
 AWS Lambda Guía para desarrolladores
Tutorial

$ aws apigateway put-method-response --rest-api-id $API \

--resource-id $RESOURCE --http-method POST \
--status-code 200 --response-models application/json=Empty
{
"statusCode": "200",
"responseModels": {
"application/json": "Empty"
}
}

• Ejecute el siguiente comando para establecer la respuesta de integración del método POST en JSON.
Este es el tipo de respuesta que devuelve la función de Lambda.

$ aws apigateway put-integration-response --rest-api-id $API \

--resource-id $RESOURCE --http-method POST \
--status-code 200 --response-templates application/json=""
{
"statusCode": "200",
"responseTemplates": {
"application/json": null
}
}

Implementar la API
En este paso, implementará la API que ha creado en una etapa denominada prod.

$ aws apigateway create-deployment --rest-api-id $API --stage-name prod

{
"id": "20vgsz",
"createdDate": 1539820012
}

Conceda permiso de invocación al API

Ahora que ha creado una API con Amazon API Gateway y la ha implementado, puede probarla. En primer
lugar, debe agregar permisos para que Amazon API Gateway; pueda invocar la función de Lambda cuando
se envía la solicitud HTTP al método POST.

Para ello, debe añadir un permiso a la política de permisos asociada a la función de Lambda. Ejecute el
siguiente comando add-permission de AWS Lambda para conceder a la entidad principal del servicio
de Amazon API Gateway ([Link]) permisos para invocar la función de Lambda
(LambdaFunctionOverHttps).

$ aws lambda add-permission --function-name LambdaFunctionOverHttps \

--statement-id apigateway-test-2 --action lambda:InvokeFunction \
--principal [Link] \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/*/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-east-2:123456789012:function:LambdaFunctionOverHttps\",\"Condition
\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1yprki7/
*/POST/DynamoDBManager\"}}}"
}

Debe conceder este permiso para poder realizar pruebas (si va a Amazon API Gateway y elige Test
(Probar) para probar el método de la API, necesitará este permiso). Observe que --source-arn

170
 AWS Lambda Guía para desarrolladores
Tutorial

especifica un carácter comodín (*) como valor para la etapa (indica que solo es para pruebas). Esto le
permite hacer pruebas sin implementar la API.
Note

Si la función y la API se encuentran en regiones diferentes, el identificador de región en el ARN

del origen debe coincidir con la región de la función, no la región de la API.

Ahora, ejecute el mismo comando de nuevo, pero esta vez conceda a la API implementada permisos para
invocar la función de Lambda.

$ aws lambda add-permission --function-name LambdaFunctionOverHttps \

--statement-id apigateway-prod-2 --action lambda:InvokeFunction \
--principal [Link] \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/prod/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-prod-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-east-2:123456789012:function:LambdaFunctionOverHttps\",\"Condition
\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1yprki7/
prod/POST/DynamoDBManager\"}}}"
}

Puede conceder este permiso para que la API implementada tenga permisos para invocar la función de
Lambda. Observe que --source-arn especifica prod, que es el nombre de la etapa que se utilizó al
implementar la API.

Cree una tabla de Amazon DynamoDB.

Cree la tabla de DynamoDB que usa la funció de Lambda.

Para crear una tabla de DynamoDB

1. Abra la consola de DynamoDB.

2. Seleccione Create table.
3. Cree una tabla con la siguiente configuración:

• Nombre de la tabla – lambda-apigateway

• Primary key (Clave principal) – id (cadena)
4. Seleccione Create.

Desencadene la función con una solicitud HTTP.

En este paso, puede enviar una solicitud HTTP al punto de enlace del método POST. Puede utilizar Curl o
un método (test-invoke-method) proporcionado por Amazon API Gateway.

Puede utilizar comandos de la CLI de Amazon API Gateway para enviar una solicitud de HTTP POST al
punto de enlace del recursoDynamoDBManager. Dado que ha implementado su Amazon API Gateway,
puede utilizar Curl para invocar los métodos para realizar la misma operación.

La función de Lambda permite utilizar la operación create para crear un elemento en la tabla de
DynamoDB. Para solicitar esta operación, utilice el siguiente JSON:

Example [Link]

171
 AWS Lambda Guía para desarrolladores
Código de muestra

"operation": "create",
"tableName": "lambda-apigateway",
"payload": {
"Item": {
"id": "1234ABCD",
"number": 5
}
}
}

Guarde la información de pruebas en un archivo llamado [Link]. Ejecute el comando de

Amazon API Gateway test-invoke-method para enviar una solicitud de método HTTP POST al punto
de enlace recursoDynamoDBManager

$ aws apigateway test-invoke-method --rest-api-id $API \

--resource-id $RESOURCE --http-method POST --path-with-query-string "" \
--body [Link]

También puede utilizar el siguiente comando Curl:

$ curl -X POST -d "{\"operation\":\"create\",\"tableName\":\"lambda-apigateway\",

\"payload\":{\"Item\":{\"id\":\"1\",\"name\":\"Bob\"}}}" [Link]
$[Link]/prod/DynamoDBManager

Para enviar la solicitud para la operación echo que admite la función de Lambda, puede utilizar la
siguiente carga de solicitud:

Example [Link]

{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}

Guarde la información de pruebas en un archivo llamado [Link]. Ejecute el comando CLI de Amazon
API Gateway test-invoke-method para enviar una solicitud de método HTTP POST al punto de enlace
recursoDynamoDBManagerusando el JSON anterior en el cuerpo de solicitud.

$ aws apigateway test-invoke-method --rest-api-id $API \

--resource-id $RESOURCE --http-method POST --path-with-query-string "" \
--body [Link]

También puede utilizar el siguiente comando Curl:

$ curl -X POST -d "{\"operation\":\"echo\",\"payload\":{\"somekey1\":\"somevalue1\",

\"somekey2\":\"somevalue2\"}}" [Link]
DynamoDBManager

Código de función de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas

172
 AWS Lambda Guía para desarrolladores
Código de muestra

• [Link] (p. 173)

• Python 3 (p. 174)
• Go (p. 174)

[Link]
El siguiente ejemplo procesa mensajes desde API Gateway y administra documentos DynamoDB basados
en el método requerido.

Example [Link]

[Link]('Loading function');

var AWS = require('aws-sdk');

var dynamo = new [Link]();

/**
* Provide an event that contains the following keys:
*
* - operation: one of the operations in the switch statement below
* - tableName: required for operations that interact with DynamoDB
* - payload: a parameter to pass to the operation being performed
*/
[Link] = function(event, context, callback) {
//[Link]('Received event:', [Link](event, null, 2));

var operation = [Link];

if ([Link]) {
[Link] = [Link];
}

switch (operation) {
case 'create':
[Link]([Link], callback);
break;
case 'read':
[Link]([Link], callback);
break;
case 'update':
[Link]([Link], callback);
break;
case 'delete':
[Link]([Link], callback);
break;
case 'list':
[Link]([Link], callback);
break;
case 'echo':
callback(null, "Success");
break;
case 'ping':
callback(null, "pong");
break;
default:
callback('Unknown operation: ${operation}');
}
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

173
 AWS Lambda Guía para desarrolladores
Código de muestra

Python 3
El siguiente ejemplo procesa mensajes desde API Gateway y administra documentos DynamoDB basados
en el método requerido.

Example [Link]

from __future__ import print_function

import boto3
import json

print('Loading function')

def handler(event, context):

'''Provide an event that contains the following keys:

- operation: one of the operations in the operations dict below

- tableName: required for operations that interact with DynamoDB
- payload: a parameter to pass to the operation being performed
'''
#print("Received event: " + [Link](event, indent=2))

operation = event['operation']

if 'tableName' in event:
dynamo = [Link]('dynamodb').Table(event['tableName'])

operations = {
'create': lambda x: dynamo.put_item(**x),
'read': lambda x: dynamo.get_item(**x),
'update': lambda x: dynamo.update_item(**x),
'delete': lambda x: dynamo.delete_item(**x),
'list': lambda x: [Link](**x),
'echo': lambda x: x,
'ping': lambda x: 'pong'
}

if operation in operations:
return operations[operation]([Link]('payload'))
else:
raise ValueError('Unrecognized operation "{}"'.format(operation))

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Go
El siguiente ejemplo procesa mensajes desde API Gateway y registra información basada en la petición.

Example [Link]

import (
"strings"
"[Link]/aws/aws-lambda-go/events"
)

func handleRequest(ctx [Link], request [Link])

([Link], error) {

174
 AWS Lambda Guía para desarrolladores
Proyecto de microservicio

[Link]("Processing request data for request %s.\n",

[Link])
[Link]("Body size = %d.\n", len([Link]))

[Link]("Headers:")
for key, value := range [Link] {
[Link](" %s: %s\n", key, value)
}

return [Link] { Body: [Link], StatusCode: 200 }, nil

}

Compile el ejecutable con go build y cree un paquete de implementación. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en Go (p. 359).

Creación de un microservicio sencillo utilizando

Lambda y API Gateway
En este ejercicio, utilizará la consola de Lambda para crear una función de Lambda y un punto de enlace
de Amazon API Gateway para activar dicha función. Podrá llamar al punto de enlace con cualquier método
(GET, POST, PATCH, etc.) para desencadenar la función de Lambda. Una vez realizada la llamada al punto
de enlace, se pasará la solicitud completa a la función de Lambda. La acción de la función dependerá del
método con el que llame al punto de enlace:

• DELETE: elimina un elemento de una tabla de DynamoDB

• GET: examina la tabla y devuelve todos los elementos
• POST: crea un elemento
• PUT: actualiza un elemento

Creación de un Amazon API Gateway usuario de AP.

Siga los pasos de esta sección para crear una nueva función de Lambda y un punto de enlace de API
Gateway para activarla:

Para crear un API

1. Inicie sesión en la consola de administración de AWS y abra la consola de AWS Lambda.

2. Seleccione Create Lambda function.
3. Elija el Blueprint (Proyecto).
4. Escriba microservice en la barra de búsqueda. Elija el microservice-http-endpoint proyecto y, a
continuación, elija Configurar.
5. Configure los siguientes ajustes.

• Nombre – lambda-microservice.
• Rol – Crear un rol nuevo a partir de una o varias plantillas.
• Role name (Nombre de rol): lambda-apigateway-role.
• Plantillas de política – Simple microservice permissions (Permisos de microservicio simples).
• API – Crear un nuevo API.
• Seguridad – Abrir.

Elija Create function.

175
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

Cuando complete el asistente y cree la función, Lambda crea un recurso proxy llamado lambda-
microservice bajo el nombre API seleccionado. Para obtener más información acerca de los recursos
de proxy, consulte Configuración de la integración del proxy para un recurso proxy.

Un recurso de proxy tiene un tipo de integración AWS_PROXY y un método catch-all ANY. El tipo de
integración AWS_PROXY aplica una plantilla de mapeo predeterminada para pasar toda la solicitud a la
función de Lambda y transforma la salida de la función de Lambda en respuestas HTTP. El método ANY
define la misma configuración de integración para todos los métodos admitidos, incluidos GET, POST,
PATCH, DELETE y otros.

Prueba de envío de una solicitud HTTPS

En este paso, utilizará la consola para probar la función de Lambda. Además, puede ejecutar un comando
curl para probar la experiencia integral. Es decir, enviar una solicitud HTTPS a su método de la API
y hacer que Amazon API Gateway invoque la función de Lambda. Con el fin de completar los pasos,
asegúrese de que ha creado una tabla de DynamoDB denominada “MyTable”. Para obtener más
información, consulte Crear una tabla DynamoDB con una secuencia habilitada (p. 213)

Para probar el API

1. Con la función MyLambdaMicroService aún abierta en la consola, en la pestaña Actions, elija

Configure test event.
2. Reemplace el texto existente por el siguiente:

{
"httpMethod": "GET",
"queryStringParameters": {
"TableName": "MyTable"
}
}

3. Una vez introducido el texto anterior, elija Save and test.

Plantilla de AWS SAM para una aplicación de API

Gateway
A continuación, hay una plantilla AWS SAM de muestra para la aplicación de Lambda del
tutorial (p. 164). Copie el texto siguiente en un archivo y guárdelo junto al paquete ZIP que ha creado
anteriormente. Tenga en cuenta que los valores de los parámetros Handler y Runtime deben coincidir
con los que utilizó cuando creó la función en la sección anterior.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
LambdaFunctionOverHttps:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
Policies: AmazonDynamoDBFullAccess
Events:
HttpPost:
Type: Api
Properties:
Path: '/DynamoDBOperations/DynamoDBManager'

176
 AWS Lambda Guía para desarrolladores
AWS CloudTrail

Method: post

Para obtener más informaciónsobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

Uso de AWS Lambda con AWS CloudTrail

AWS CloudTrail es un servicio que proporciona un registro de las acciones realizadas por un usuario,
un rol o un servicio de AWS. CloudTrail captura las llamadas a la API como eventos. Para mantener un
registro continuo de los eventos de la cuenta de AWS, cree un registro de seguimiento. Un registro de
seguimiento permite a CloudTrail enviar archivos de registro de eventos a un bucket de Amazon S3.

Puede utilizar la característica de notificaciones de los buckets de Amazon S3 y hacer que Amazon S3
publique eventos de creación de objetos para AWS Lambda. Siempre que CloudTrail escriba registros en
el bucket de S3, Amazon S3 puede invocar la función de Lambda pasando el evento de creación de objeto
de Amazon S3 como parámetro. El evento de S3 proporciona información, incluido el nombre del bucket
y el nombre de la clave del objeto de log creado por CloudTrail. El código de la función de Lambda puede
leer el objeto del registro y procesar los registros de acceso generados por CloudTrail. Por ejemplo, puede
escribir el código de una función de Lambda para que le notifique si se ha realizado una llamada a una API
específica en su cuenta.

En este caso, CloudTrail escribe los registros de acceso a su bucket de S3. En cuanto a AWS Lambda,
Amazon S3 es el origen de eventos, por lo que Amazon S3 publica los eventos para AWS Lambda e
invoca la función de Lambda.

Example Registro de CloudTrail

{
"Records":[
{
"eventVersion":"1.02",
"userIdentity":{
"type":"Root",
"principalId":"123456789012",
"arn":"arn:aws:iam::123456789012:root",
"accountId":"123456789012",
"accessKeyId":"access-key-id",
"sessionContext":{
"attributes":{
"mfaAuthenticated":"false",
"creationDate":"2015-01-24T22:41:54Z"
}
}
},
"eventTime":"2015-01-24T23:26:50Z",
"eventSource":"[Link]",
"eventName":"CreateTopic",
"awsRegion":"us-east-2",
"sourceIPAddress":"[Link]",
"userAgent":"[Link]",
"requestParameters":{
"name":"dropmeplease"
},
"responseElements":{
"topicArn":"arn:aws:sns:us-east-2:123456789012:exampletopic"
},
"requestID":"3fdb7834-9079-557e-8ef2-350abc03536b",
"eventID":"17b46459-dada-4278-b8e2-5a4ca9ff1a9c",

177
 AWS Lambda Guía para desarrolladores
Tutorial

"eventType":"AwsApiCall",
"recipientAccountId":"123456789012"
},
{
"eventVersion":"1.02",
"userIdentity":{
"type":"Root",
"principalId":"123456789012",
"arn":"arn:aws:iam::123456789012:root",
"accountId":"123456789012",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"sessionContext":{
"attributes":{
"mfaAuthenticated":"false",
"creationDate":"2015-01-24T22:41:54Z"
}
}
},
"eventTime":"2015-01-24T23:27:02Z",
"eventSource":"[Link]",
"eventName":"GetTopicAttributes",
"awsRegion":"us-east-2",
"sourceIPAddress":"[Link]",
"userAgent":"[Link]",
"requestParameters":{
"topicArn":"arn:aws:sns:us-east-2:123456789012:exampletopic"
},
"responseElements":null,
"requestID":"4a0388f7-a0af-5df9-9587-c5c98c29cbec",
"eventID":"ec5bb073-8fa1-4d45-b03c-f07b9fc9ea18",
"eventType":"AwsApiCall",
"recipientAccountId":"123456789012"
}
]
}

Para obtener información detallada acerca de cómo configurar Amazon S3 como origen de eventos,
consulte Uso de AWS Lambda con eventos de Amazon S3 (p. 254).

Temas
• Tutorial: Activación de una función Lambda con eventos de AWS CloudTrail (p. 178)
• Código de función de muestra (p. 183)

Tutorial: Activación de una función Lambda con

eventos de AWS CloudTrail
Puede configurar Amazon S3 para que publique eventos en AWS Lambda cuando AWS CloudTrail
almacene registros de llamadas a la API. El código de la función Lambda puede leer el objeto de registro y
procesar los registros de acceso generados por CloudTrail.

Utilice las siguientes instrucciones para crear una función Lambda que le avise cuando se produzca una
llamada a la API específica en su cuenta. La función procesa eventos de notificación de Amazon S3, lee
registros de un bucket y publica alertas a través de un tema de Amazon SNS. En este tutorial, va a crear:

• Un registro de seguimiento de CloudTrail y un bucket de S3 en los que guardar los registros.

• Un tema de Amazon SNS para publicar notificaciones de alertas.
• Un rol de usuario de IAM con permisos para leer elementos de un bucket de S3 y escribir registros en
Amazon CloudWatch.

178
 AWS Lambda Guía para desarrolladores
Tutorial

• Una función Lambda que procesa registros de CloudTrail y envía una notificación cada vez que se crea
un tema de Amazon SNS.

Requisitos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Antes de comenzar, asegúrese de que dispone de las siguientes herramientas:

• [Link] 8 con npm.

• El shell Bash. Se incluye de forma predeterminada para Linux y macOS. En Windows 10, puede instalar
el Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.
• La CLI de AWS.

Paso 1: Creación de un registro de seguimiento en CloudTrail

Al crear un registro de seguimiento, CloudTrail registra las llamadas a la API en archivos de registro y las
almacena en Amazon S3. Un log de CloudTrail es una matriz desordenada de eventos con formato JSON.
En cada llamada que se realiza a una acción de la API admitida, CloudTrail registra información sobre la
solicitud y la entidad que la hizo. Los eventos de registro incluyen el nombre de la acción, los parámetros,
los valores de respuesta y los datos del solicitante.

Para crear un registro de seguimiento

1. Abra la página Trails (Registros de seguimiento) de la consola de CloudTrail.

2. Elija Create Trail (Crear registro de seguimiento).
3. En Trail name (Nombre de registro de seguimiento), escriba un nombre.
4. En S3 bucket (Bucket de S3), escriba un nombre.
5. Seleccione Create.
6. Guarde el nombre de recurso de Amazon (ARN) del bucket para añadirlo al rol de ejecución de IAM,
que creará más adelante.

Paso 2: Creación de un tema de Amazon SNS

Cree un tema de Amazon SNS para enviar una notificación cuando se produzcan nuevos eventos de
objetos.

Para crear un tema

1. Abra la página Topics (Temas) en la consola de Amazon SNS.

2. Elija Create new topic (Crear nuevo tema).
3. En Topic name (Nombre del tema), escriba un nombre.
4. Elija Create new topic (Crear nuevo tema).
5. Registre el ARN del tema. Lo necesitará cuando cree el rol de ejecución de IAM y la función Lambda.

179
 AWS Lambda Guía para desarrolladores
Tutorial

Paso 3: Creación de un rol de ejecución de IAM

Un rol de ejecución (p. 32) concede a su función permiso para obtener acceso a los recursos de AWS.
Cree un rol de ejecución que conceda a la función permiso para obtener acceso a CloudWatch Logs,
Amazon S3 y Amazon SNS.

Para crear un rol de ejecución

1. Abra la página Roles de la consola de IAM.

2. Elija Create role.
3. Cree un rol con las propiedades siguientes:

• En Trusted entity (Entidad de confianza), elija Lambda.

• En Role name (Nombre del rol), escriba lambda-cloudtrail-role.
• En Permissions (Permisos), cree una política personalizada con las siguientes instrucciones.
Sustituya los valores resaltados por los nombres de su bucket y tema.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:*"
],
"Resource": "arn:aws:logs:*:*:*"
},
{
"Effect": "Allow",
"Action": [
"s3:GetObject"
],
"Resource": "arn:aws:s3:::my-bucket/*"
},
{
"Effect": "Allow",
"Action": [
"sns:Publish"
],
"Resource": "arn:aws:sns:us-west-2:123456789012:my-topic"
}
]
}

4. Registre el ARN de rol. Lo necesitará cuando cree la función Lambda.

Paso 4: Creación de la función Lambda

La siguiente función Lambda procesa los registros de CloudTrail y envía una notificación a través de
Amazon SNS cuando se crea un nuevo tema de Amazon SNS.

Para crear la función

1. Cree una carpeta y asígnele un nombre que indique que es su función Lambda (por ejemplo,
lambda-cloudtrail).
2. En la carpeta, cree un archivo llamado [Link].
3. Pegue el siguiente código en [Link]. Sustituya el ARN del tema de Amazon SNS por el ARN que
Amazon S3 creó cuando se creó el tema de Amazon SNS.

180
 AWS Lambda Guía para desarrolladores
Tutorial

var aws = require('aws-sdk');

var zlib = require('zlib');
var async = require('async');

var EVENT_SOURCE_TO_TRACK = /[Link]/;

var EVENT_NAME_TO_TRACK = /CreateTopic/;
var DEFAULT_SNS_REGION = 'us-east-2';
var SNS_TOPIC_ARN = 'arn:aws:sns:us-west-2:123456789012:my-topic';

var s3 = new aws.S3();

var sns = new [Link]({
apiVersion: '2010-03-31',
region: DEFAULT_SNS_REGION
});

[Link] = function(event, context, callback) {

var srcBucket = [Link][0].[Link];
var srcKey = [Link][0].[Link];

[Link]([
function fetchLogFromS3(next){
[Link]('Fetching compressed log from S3...');
[Link]({
Bucket: srcBucket,
Key: srcKey
},
next);
},
function uncompressLog(response, next){
[Link]("Uncompressing log...");
[Link]([Link], next);
},
function publishNotifications(jsonBuffer, next) {
[Link]('Filtering log...');
var json = [Link]();
[Link]('CloudTrail JSON from S3:', json);
var records;
try {
records = [Link](json);
} catch (err) {
next('Unable to parse CloudTrail JSON: ' + err);
return;
}
var matchingRecords = records
.Records
.filter(function(record) {
return [Link](EVENT_SOURCE_TO_TRACK)
&& [Link](EVENT_NAME_TO_TRACK);
});

[Link]('Publishing ' + [Link] + ' notification(s) in

parallel...');
[Link](
matchingRecords,
function(record, publishComplete) {
[Link]('Publishing notification: ', record);
[Link]({
Message:
'Alert... SNS topic created: \n TopicARN=' +
[Link] + '\n\n' +
[Link](record),
TopicArn: SNS_TOPIC_ARN
}, publishComplete);
},

181
 AWS Lambda Guía para desarrolladores
Tutorial

next
);
}
], function (err) {
if (err) {
[Link]('Failed to publish notifications: ', err);
} else {
[Link]('Successfully published all notifications.');
}
callback(null,"message");
});
};

4. En la carpeta lambda-cloudtrail ejecute el siguiente script. Crea un archivo package-

[Link] y una carpeta node_modules, que gestionan todas las dependencias.

$ npm install async

5. Ejecute el siguiente script para crear un paquete de implementación.

$ zip -r [Link] .

6. Cree una función Lambda denominada CloudTrailEventProcessing con el comando create-

function ejecutando el siguiente script. Realice las sustituciones que se indican.

$ aws lambda create-function --function-name CloudTrailEventProcessing \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x --timeout
10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/lambda-cloudtrail-role

Paso 5: Añadir permisos a la política de la función Lambda

Añada permisos a la política de la función Lambda para permitir que Amazon S3 invoque la función.

Para conceder a Amazon S3 permisos para invocar la función

1. Ejecute el siguiente comando add-permission. Sustituya el ARN y el ID de cuenta por los suyos
propios.

$ aws lambda add-permission --function-name CloudTrailEventProcessing \

--statement-id Id-1 --action "lambda:InvokeFunction" --principal [Link] \
--source-arn arn:aws:s3:::my-bucket \
--source-account 123456789012

Este comando concede a la entidad principal del servicio Amazon S3 ([Link]) permisos
para realizar la acción lambda:InvokeFunction. Los permisos de invocación se conceden a
Amazon S3 solo si se cumplen las siguientes condiciones:

• CloudTrail almacena un objeto de registro en el bucket especificado.

• El bucket es propiedad de la cuenta de AWS especificada. Si el propietario del bucket lo elimina,
otra cuenta de AWS puede crear un bucket con el mismo nombre. Esta condición garantiza que solo
la cuenta especificada deAWS pueda invocar la función Lambda.
2. Para ver la política de acceso de la función Lambda, ejecute el siguiente comando get-policy y
sustituya el nombre de la función.

$ aws lambda get-policy --function-name function-name

182
 AWS Lambda Guía para desarrolladores
Código de muestra

Paso 6: Configuración de notificaciones en un bucket de Amazon

S3
Para solicitar que Amazon S3 publique eventos de creación de objetos en Lambda, añada una
configuración de notificación al bucket de S3. En la configuración, especifique lo siguiente:

• Tipo de evento – Cualquier evento que cree objetos.

• Función Lambda: la función Lambda que desea que Amazon S3 invoque.

Para configurar notificaciones

1. Abra la consola de Amazon S3.

2. Elija el bucket de origen
3. Seleccione Properties (Propiedades).
4. En Events (Eventos), configure una notificación con las siguientes especificaciones.

• Name (Nombre): lambda-trigger

• Events (Eventos): All object create events
• Send to (Enviar a):– Lambda function
• Lambda: CloudTrailEventProcessing

Cuando CloudTrail almacena registros en el bucket, Amazon S3 envía un evento a la función. El evento
proporciona información, incluido el nombre del bucket y el nombre de la clave del objeto de registro
creado por CloudTrail.

Código de función de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• [Link] (p. 183)

[Link]
El ejemplo siguiente procesa registros de CloudTrail y envía una notificación cuando se crea un tema de
Amazon SNS.

Example [Link]

var aws = require('aws-sdk');

var zlib = require('zlib');
var async = require('async');

var EVENT_SOURCE_TO_TRACK = /[Link]/;

var EVENT_NAME_TO_TRACK = /CreateTopic/;
var DEFAULT_SNS_REGION = 'us-west-2';
var SNS_TOPIC_ARN = 'The ARN of your SNS topic';

var s3 = new aws.S3();

var sns = new [Link]({
apiVersion: '2010-03-31',
region: DEFAULT_SNS_REGION
});

183
 AWS Lambda Guía para desarrolladores
Código de muestra

[Link] = function(event, context, callback) {

var srcBucket = [Link][0].[Link];
var srcKey = [Link][0].[Link];

[Link]([
function fetchLogFromS3(next){
[Link]('Fetching compressed log from S3...');
[Link]({
Bucket: srcBucket,
Key: srcKey
},
next);
},
function uncompressLog(response, next){
[Link]("Uncompressing log...");
[Link]([Link], next);
},
function publishNotifications(jsonBuffer, next) {
[Link]('Filtering log...');
var json = [Link]();
[Link]('CloudTrail JSON from S3:', json);
var records;
try {
records = [Link](json);
} catch (err) {
next('Unable to parse CloudTrail JSON: ' + err);
return;
}
var matchingRecords = records
.Records
.filter(function(record) {
return [Link](EVENT_SOURCE_TO_TRACK)
&& [Link](EVENT_NAME_TO_TRACK);
});

[Link]('Publishing ' + [Link] + ' notification(s) in

parallel...');
[Link](
matchingRecords,
function(record, publishComplete) {
[Link]('Publishing notification: ', record);
[Link]({
Message:
'Alert... SNS topic created: \n TopicARN=' +
[Link] + '\n\n' +
[Link](record),
TopicArn: SNS_TOPIC_ARN
}, publishComplete);
},
next
);
}
], function (err) {
if (err) {
[Link]('Failed to publish notifications: ', err);
} else {
[Link]('Successfully published all notifications.');
}
callback(null,"message");
});
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

184
 AWS Lambda Guía para desarrolladores
Eventos de CloudWatch

Uso de AWS Lambda con Amazon CloudWatch

Events
Amazon CloudWatch Eventos le ayuda a responder a los cambios de estado de los recursos de AWS.
Cuando cambia el estado de los recursos, estos envían automáticamente eventos a un flujo de eventos.
Puede crear reglas que coincidan con los eventos seleccionados en el flujo y los transfieran a una función
de AWS Lambda para realizar alguna acción. Por ejemplo, puede invocar automáticamente una función de
AWS Lambda para registrar el estado de una instancia EC2 o un grupo de Auto Scaling.

El mapeo de origen de eventos se mantiene en Amazon CloudWatch Events mediante la utilización de

una definición de destino de regla. Para obtener más información, consulte la operación PutTargets en la
Referencia de la API de Amazon CloudWatch Events.

También puede crear una función de Lambda y configurar AWS Lambda para que la ejecute de manera
periódica. Puede especificar una frecuencia fija (por ejemplo, ejecutar una función de Lambda cada hora
o cada 15 minutos), o puede especificar una expresión Cron. Para obtener más información sobre las
expresiones de programación, consulte Programación de expresiones con rate o cron (p. 189).

Example Evento de mensaje de Eventos de CloudWatch

{
"account": "123456789012",
"region": "us-east-2",
"detail": {},
"detail-type": "Scheduled Event",
"source": "[Link]",
"time": "2019-03-01T01:23:45Z",
"id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c",
"resources": [
"arn:aws:events:us-east-1:123456789012:rule/my-schedule"
]
}

Esta funcionalidad está disponible cuando se crea una función de Lambda mediante la consola de AWS
Lambda o la AWS CLI. Para configurarla con la AWS CLI, consulte Ejecutar una función de AWS Lambda
en una programación mediante de la CLI de AWS. La consola ofrece CloudWatch Events (Eventos de
CloudWatch) como origen de eventos. En el momento de crear una función de Lambda, puede seleccionar
este origen de eventos y especificar un intervalo de tiempo.

Si ha realizado cambios manuales en los permisos de la función, es posible que necesite volver a aplicar el
acceso de eventos programados a la función. Puede hacerlo con el siguiente comando de la CLI.

$ aws lambda add-permission --function-name my-function\

--action 'lambda:InvokeFunction' --principal [Link] --statement-id
events-access \
--source-arn arn:aws:events:*:123456789012:rule/*

Cada cuenta de AWS puede tener un máximo de 100 orígenes de eventos exclusivos de tipo Eventos
de CloudWatch - Schedule (Programación de CloudWatch). Cada uno de ellos puede ser el origen de
eventos de hasta cinco funciones de Lambda. Es decir, puede tener hasta 500 funciones de Lambda que
se ejecuten de forma programada en su cuenta de AWS.

En la consola también hay un proyecto (lambda-canary) que utiliza el tipo de origen Eventos de
CloudWatch - Schedule (Programación de CloudWatch). Con este proyecto, puede crear una función
de Lambda de muestra y probar esta característica. El código de ejemplo del proyecto comprueba la

185
 AWS Lambda Guía para desarrolladores
Tutorial

existencia de una página web específica y de una cadena de texto determinada en ella. Si no se encuentra
la página web o la cadena de texto, la función de Lambda genera un error.

Tutorial: Uso de AWS Lambda con eventos

programados
En este tutorial, aprenderá a hacer lo siguiente:

• Crear una función de Lambda utilizando el proyecto lambda-canary. También configurará la función de
Lambda para que se ejecute cada minuto. Tenga en cuenta que si la función devuelve un error, AWS
Lambda registra las métricas de error en CloudWatch.
• Configurar una alarma de CloudWatch en la métrica Errors de la función de Lambda para que
publique un mensaje en el tema de Amazon SNS cuando AWS Lambda envíe las métricas de error
a CloudWatch. Debe suscribirse a los temas de Amazon SNS para obtener notificaciones por correo
electrónico. En este tutorial, hará lo siguiente para configurar esto:
• Creación de un tema de Amazon SNS.
• Suscribirse al tema para poder recibir notificaciones por correo electrónico cuando se publique un
mensaje nuevo en el tema.
• En Amazon CloudWatch, configure una alarma en la métrica Errors de la función de Lambda para
publicar un mensaje en el tema de SNS cuando se produzcan errores.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Creación de una función Lambda

1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Lambda en https://
[Link]/lambda/.
2. Elija Create function.
3. Elija el Proyecto.
4. Escriba canary en la barra de búsqueda. Elija proyecto lambda-canary y, a continuación, elija
Configure (Configurar).
5. Configure los siguientes ajustes.

• Nombre – lambda-canary.
• Rol – Crear un rol nuevo a partir de una o varias plantillas.
• Role name (Nombre de rol): lambda-apigateway-role.
• Plantillas de política – Simple microservice permissions (Permisos de microservicio simples).
• Regla – Crear nueva regla.
• Nombre de la regla' – CheckWebsiteScheduledEvent.
• Rule description (Descripción de regla) – CheckWebsiteScheduledEvent trigger.
• Schedule expression (Expresión de programación) – rate(1 minute).
• Habilitado – Cierto (comprobado).
• Variables de entorno
• site: [Link]
• expected: What Is AWS Lambda?
6. Elija Create function.

186
 AWS Lambda Guía para desarrolladores
Tutorial

Eventos de CloudWatch emite un evento cada minuto basado en la expresión de programación. El

evento desencadena la función de Lambda, la cual verifica que la cadena esperada aparezca en la
página especificada. Para obtener más información sobre las expresiones de programación, consulte
Programación de expresiones con rate o cron (p. 189).

Pruebe la función Lambda.

Compruebe la función con un evento de muestra proporcionado por la consola de Lambda.

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija lambda-canary.
3. Junto al botón de Prueba en la parte superior de la página, seleccione Configure teste events
(Configure eventos de prueba) en el menú desplegable.
4. Cree un evento nuevo usando la plantilla de evento de Eventos de CloudWatch.
5. Seleccione Create.
6. Elija Test.

La salida de la ejecución de función aparece en la parte superior de la página.

Cree un tema de Amazon SNS y suscríbase a él.

Cree un tema de Amazon Simple Notification Service (Amazon SNS) para recibir notificaciones cuando la
función de valor controlado devuelva un error.

Para crear un tema

1. Abra la consola de Amazon SNS.

2. Elija Create new topic.
3. Cree un tema con la siguiente configuración:

• Nombre – lambda-canary-notifications.
• Nombre que mostrar – Canary.
4. Seleccione Create subscription.
5. Cree una suscripción con la siguiente configuración:

• Protocolo – Email.
• Punto de enlace – Su dirección de email.

Amazon SNS envía un email desde Canary <no-reply@[Link]>, que refleja el nombre
intuitivo del tema. Use el enlace del correo electrónico para verificar la dirección.

Configure una alarma:

Configure una alarma en Amazon CloudWatch que monitorice la función de Lambda que envía una
notificación cuando falla.

Para crear una alarma

1. Abra la consola de CloudWatch.

2. Elija Alarms (Alarmas).
3. Elija Crear alarma.

187
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

4. Elija Alarms (Alarmas).

5. Cree una alarma con la siguiente configuración:

• Métricas – Errores lambda-canary.

Buscar lambda canary errors para encontrar la métrica.

• Estadística – Sum

Elija la estadística en el menú desplegable sobre el menú gráfico de previsualización.

• Nombre – lambda-canary-alarm.
• Descripción – Lambda canary alarm
• Umbral – Whenever Errors is (Cuando el error sea) >=1
• Enviar notificación a: lambda-canary-notifications

Pruebe la alarma.
Actualice la configuración de función para hacer que la función devuelva un error, lo que activa la alarma.

Para activar una alarma

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija lambda-canary.
3. En Environment variables (Variables de entorno), elija Edit (Editar).
4. Establezca expected en 404.
5. Elija Save (Guardar).

Tras un minuto, busque en su correo electrónico un mensaje de Amazon SNS.

Plantilla de AWS SAM para una aplicación de Eventos

de CloudWatch
Puede construir esta aplicación utilizando AWS SAM. Para obtener más información sobre la creación
de plantillas AWS SAM, diríjase a AWS SAM Aspectos básicos sobre plantillas en la Guía para
desarrolladores deModelo de aplicación sin servidor de AWS.

A continuación, hay una plantilla AWS SAM de muestra para la aplicación de Lambda del
tutorial (p. 186). Copie el texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha
creado anteriormente. Tenga en cuenta que los valores de los parámetros Handler y Runtime deben
coincidir con los que utilizó cuando creó la función en la sección anterior.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Parameters:
NotificationEmail:
Type: String
Resources:
CheckWebsitePeriodically:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: runtime

188
 AWS Lambda Guía para desarrolladores
Programación de expresiones

Policies: AmazonDynamoDBFullAccess
Events:
CheckWebsiteScheduledEvent:
Type: Schedule
Properties:
Schedule: rate(1 minute)

AlarmTopic:
Type: AWS::SNS::Topic
Properties:
Subscription:
- Protocol: email
Endpoint: !Ref NotificationEmail

Alarm:
Type: AWS::CloudWatch::Alarm
Properties:
AlarmActions:
- !Ref AlarmTopic
ComparisonOperator: GreaterThanOrEqualToThreshold
Dimensions:
- Name: FunctionName
Value: !Ref CheckWebsitePeriodically
EvaluationPeriods: 1
MetricName: Errors
Namespace: AWS/Lambda
Period: 60
Statistic: Sum
Threshold: '1'

Para obtener más informaciónsobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

Programación de expresiones con rate o cron

AWS Lambda admite expresiones rate y cron estándar para frecuencias de hasta una vez por minuto. Las
expresiones rate de Eventos de CloudWatch tienen el formato siguiente.

rate(Value Unit)

Donde Value es un número entero positivo y Unit puede expresarse en minutos, horas o días. Si el valor
es 1, la unidad debe ir en singular (por ejemplo, rate(1 day)); para otros valores, en plural (por ejemplo,
rate(5 days)).

Ejemplos de expresiones rate

Frecuencia Expresión

Cada 5 minutos rate(5 minutes)

Cada hora rate(1 hour)

Cada siete días rate(7 days)

Las expresiones cron tienen el formato siguiente.

cron(Minutes Hours Day-of-month Month Day-of-week Year)

189
 AWS Lambda Guía para desarrolladores
Amazon CloudWatch Logs

Ejemplos de expresiones cron

Frecuencia Expresión

10:15 (UTC) todos los días cron(15 10 * * ? *)

18.00 de lunes a viernes cron(0 18 ? * MON-FRI *)

8:00 el último día del mes cron(0 8 1 * ? *)

Cada 10 minutos de lunes a cron(0/10 * ? * MON-FRI *)

viernes

Cada 5 minutos entre las 8:00 y cron(0/5 8-17 ? * MON-FRI *)

las 17.55 de lunes a viernes

9:00 el primer lunes de cada mes cron(0 9 ? * 2#1 *)

Tenga en cuenta lo siguiente:

• Si está usando la consola de Lambda, no incluya el prefijo cron en la expresión.

• Uno de los valores de day-of-month o day-of-week debe ser un signo de interrogación (?).

Para obtener más información, consulte Programar expresiones para reglas en la Guía del usuario de
Eventos de CloudWatch.

Uso de AWS Lambda con Amazon CloudWatch

Logs
Puede utilizar una función de Lambda para monitorizar y analizar registros de un flujo de registros de
Amazon CloudWatch Logs. Cree suscripciones a uno o varios flujos de registros para invocar una función
cuando se creen registros o estos coincidan con un patrón opcional. Utilice la función para enviar una
notificación o para conservar el registro en una base de datos o en un sistema de almacenamiento.

CloudWatch Logs invoca la función de forma asíncrona con un evento que contiene datos de registro
codificados. El valor del campo de datos es un archivo ZIP codificado en Base64.

Example Evento de mensaje de Amazon CloudWatch Logs

{
"awslogs": {
"data":
"ewogICAgIm1lc3NhZ2VUeXBlIjogIkRBVEFfTUVTU0FHRSIsCiAgICAib3duZXIiOiAiMTIzNDU2Nzg5MDEyIiwKICAgICJsb2dHc
}
}

Cuando se descodifican y descomprimen, los datos del registro son un documento JSON con la siguiente
estructura.

Example Datos de un mensaje de Amazon CloudWatch Logs (descodificados)

{
"messageType": "DATA_MESSAGE",
"owner": "123456789012",

190
 AWS Lambda Guía para desarrolladores
AWS CloudFormation

"logGroup": "/aws/lambda/echo-nodejs",
"logStream": "2019/03/13/[$LATEST]94fa867e5374431291a7fc14e2f56ae7",
"subscriptionFilters": [
"LambdaStream_cloudwatchlogs-node"
],
"logEvents": [
{
"id": "34622316099697884706540976068822859012661220141643892546",
"timestamp": 1552518348220,
"message": "REPORT RequestId: 6234bffe-149a-b642-81ff-2e8e376d8aff\tDuration:
46.84 ms\tBilled Duration: 100 ms \tMemory Size: 192 MB\tMax Memory Used: 72 MB\t\n"
}
]
}

Para ver una aplicación de ejemplo que utiliza CloudWatch Logs como desencadenador, consulte
Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Uso de AWS Lambda con AWS CloudFormation

En una plantilla de AWS CloudFormation puede especificar una función de Lambda como destino de un
recurso personalizado. Utilice los recursos personalizados para procesar parámetros, recuperar valores de
configuración o llamar a otros servicios de AWS durante los eventos del ciclo de vida de la pila.

El ejemplo siguiente invoca una función definida en otra parte de la plantilla.

Example – Definición de recurso personalizado

Resources:
primerinvoke:
Type: AWS::CloudFormation::CustomResource
Version: "1.0"
Properties:
ServiceToken: !GetAtt [Link]
FunctionName: !Ref randomerror

El token de servicio es el Nombre de recurso de Amazon (ARN) de la función que AWS CloudFormation
invoca al crear, actualizar o eliminar la pila. También puede incluir propiedades adicionales como
FunctionName, que AWS CloudFormation pasa a su función tal cual.

AWS CloudFormation invoca la función Lambda de forma asíncrona (p. 89) con un evento que incluye una
URL de devolución de llamada.

Example – Evento de mensaje de AWS CloudFormation

{
"RequestType": "Create",
"ServiceToken": "arn:aws:lambda:us-east-2:123456789012:function:lambda-error-processor-
primer-14ROR2T3JKU66",
"ResponseURL": "[Link]
[Link]/arn%3Aaws%3Acloudformation%3Aus-east-2%3A123456789012%3Astack/lambda-
error-processor/1134083a-2608-1e91-9897-022501a2c456%7Cprimerinvoke%7C5d478078-13e9-
baf0-464a-7ef285ecc786?
AWSAccessKeyId=AKIAIOSFODNN7EXAMPLE&Expires=1555451971&Signature=28UijZePE5I4dvukKQqM
%2F9Rf1o4%3D",
"StackId": "arn:aws:cloudformation:us-east-2:123456789012:stack/lambda-error-
processor/1134083a-2608-1e91-9897-022501a2c456",
"RequestId": "5d478078-13e9-baf0-464a-7ef285ecc786",
"LogicalResourceId": "primerinvoke",

191
 AWS Lambda Guía para desarrolladores
AWS CloudFormation

"ResourceType": "AWS::CloudFormation::CustomResource",
"ResourceProperties": {
"ServiceToken": "arn:aws:lambda:us-east-2:123456789012:function:lambda-error-
processor-primer-14ROR2T3JKU66",
"FunctionName": "lambda-error-processor-randomerror-ZWUC391MQAJK"
}
}

La función es responsable de devolver una respuesta a la URL de devolución de llamada que indica el
éxito o el error de la operación. Para ver la sintaxis de respuesta completa, consulte Objetos de respuesta
de recursos personalizados.

Example – Respuesta de recursos personalizados de AWS CloudFormation

{
"Status": "SUCCESS",
"PhysicalResourceId": "2019/04/18/[$LATEST]b3d1bfc65f19ec610654e4d9b9de47a0",
"StackId": "arn:aws:cloudformation:us-east-2:123456789012:stack/lambda-error-
processor/1134083a-2608-1e91-9897-022501a2c456",
"RequestId": "5d478078-13e9-baf0-464a-7ef285ecc786",
"LogicalResourceId": "primerinvoke"
}

AWS CloudFormation proporciona una biblioteca llamada cfn-response que controla el envío de
la respuesta. Si define su función dentro de una plantilla, puede solicitar la biblioteca por nombre. A
continuación, AWS CloudFormation añade la biblioteca al paquete de implementación que crea para la
función.

La función de ejemplo siguiente invoca una segunda función. Si la llamada se realiza sin error, la función
envía una respuesta de operación correcta a AWS CloudFormation y la actualización de la pila continúa.
La plantilla utiliza el tipo de recurso AWS::Serverless::Function proporcionado por Modelo de aplicación sin
servidor de AWS.

Example error-processor/[Link]: Función de recurso personalizado

Transform: 'AWS::Serverless-2016-10-31'
Resources:
primer:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
InlineCode: |
var aws = require('aws-sdk');
var response = require('cfn-response');
[Link] = function(event, context) {
// For Delete requests, immediately send a SUCCESS response.
if ([Link] == "Delete") {
[Link](event, context, "SUCCESS");
return;
}
var responseStatus = "FAILED";
var responseData = {};
var functionName = [Link]
var lambda = new [Link]();
[Link]({ FunctionName: functionName }, function(err, invokeResult) {
if (err) {
responseData = {Error: "Invoke call failed"};
[Link]([Link] + ":\n", err);
}
else responseStatus = "SUCCESS";

192
 AWS Lambda Guía para desarrolladores
CloudFront

[Link](event, context, responseStatus, responseData);

});
};
Description: Invoke a function to create a log stream.
MemorySize: 128
Timeout: 8
Role: !GetAtt [Link]
Tracing: Active

Si la función que el recurso personalizado invoca no esta definida en una plantilla, puede obtener el código
fuente de cfn-response desde el módulo cfn-response en la Guía del usuario de AWS CloudFormation.

Para ver una aplicación de ejemplo que utiliza un recurso personalizado para asegurarse de que el grupo
de registros de una función se crea antes que un recurso dependiente, consulte Aplicación de ejemplo de
procesamiento de errores para AWS Lambda (p. 141).

Para obtener más información sobre los recursos personalizados, consulte Recursos personalizados en la
Guía del usuario de AWS CloudFormation.

Uso de AWS Lambda con CloudFront

Lambda@Edge
Lambda@Edge le permite ejecutar funciones Lambda de [Link] y Python para personalizar el contenido
que ofrece CloudFront y ejecutar las funciones en las ubicaciones de AWS más cercanas al usuario.
Las funciones se ejecutan en respuesta a eventos de CloudFront, sin necesidad de aprovisionar ni
administrar servidores. Puede utilizar funciones de Lambda para cambiar las solicitudes y las respuestas
de CloudFront en los siguientes puntos:

• Después de que CloudFront reciba una solicitud de un espectador (solicitud del espectador)
• Antes de que CloudFront reenvíe la solicitud al origen (solicitud al origen)
• Después de que CloudFront reciba la respuesta del origen (respuesta del origen)
• Antes de que CloudFront reenvíe la respuesta al espectador (respuesta al espectador)

Note

Lambda@Edge admite un conjunto limitado de tiempos de ejecución y características. Para

obtener más información, consulte Requisitos y restricciones de funciones de Lambda en la guía
de Amazon CloudFront para desarrolladores.

También puede generar respuestas a los espectadores sin necesidad de enviar la solicitud al origen.

193
 AWS Lambda Guía para desarrolladores
AWS CodeCommit

Example Evento de mensaje de CloudFront

{
"Records": [
{
"cf": {
"config": {
"distributionId": "EDFDVBD6EXAMPLE"
},
"request": {
"clientIp": "2001:0db8:85a3:0:0:8a2e:0370:7334",
"method": "GET",
"uri": "/[Link]",
"headers": {
"host": [
{
"key": "Host",
"value": "[Link]"
}
],
"user-agent": [
{
"key": "User-Agent",
"value": "curl/7.51.0"
}
]
}
}
}
}
]
}

Con Lambda@Edge, puede crear una amplia variedad de soluciones, como:

• Inspeccionar las cookies para rescribir URL en diferentes versiones de un sitio y poder realizar pruebas
A/B.
• Enviar diferentes objetos a los usuarios en función del encabezado User-Agent, que contiene
información sobre el dispositivo que envió la solicitud. Por ejemplo, puede enviar imágenes en diferentes
resoluciones a los usuarios en función de sus dispositivos.
• Revisar los encabezados o los tokens autorizados, insertar el encabezado correspondiente y permitir el
control de acceso antes de reenviar una solicitud al origen.
• Añadir, eliminar y modificar encabezados, así como reescribir la ruta de la URL para dirigir a los usuarios
a distintos objetos de la caché.
• Generar nuevas respuestas HTTP para realizar tareas como redirigir a los usuarios sin autenticar a
páginas de inicio de sesión, o crear y entregar páginas web estáticas desde el borde. Para obtener más
información, consulte Utilización de funciones de Lambda para generar respuestas HTTP a solicitudes
de origen y del visor en la Guía para desarrolladores de Amazon CloudFront.

Para obtener más información sobre cómo utilizar Lambda@Edge, consulte Uso de CloudFront con
Lambda@Edge.

Uso de AWS Lambda con AWS CodeCommit

Puede crear un disparador para un repositorio de AWS CodeCommit de modo que los eventos del
repositorio invoquen la función Lambda. Por ejemplo, puede invocar una función de Lambda cuando se
crea una ramificación o una etiqueta, o cuando se envían datos a una ramificación existente.

194
 AWS Lambda Guía para desarrolladores
CodePipeline

Example Evento de mensaje de AWS CodeCommit

{
"Records": [
{
"awsRegion": "us-east-2",
"codecommit": {
"references": [
{
"commit": "5e493c6f3067653f3d04eca608b4901eb227078",
"ref": "refs/heads/master"
}
]
},
"eventId": "31ade2c7-f889-47c5-a937-1cf99e2790e9",
"eventName": "ReferenceChanges",
"eventPartNumber": 1,
"eventSource": "aws:codecommit",
"eventSourceARN": "arn:aws:codecommit:us-east-2:123456789012:lambda-pipeline-
repo",
"eventTime": "2019-03-12T20:58:25.400+0000",
"eventTotalParts": 1,
"eventTriggerConfigId": "0d17d6a4-efeb-46f3-b3ab-a63741badeb8",
"eventTriggerName": "[Link]",
"eventVersion": "1.0",
"userIdentityARN": "arn:aws:iam::123456789012:user/intern"
}
]
}

Para obtener más información, consulte Administración de los disparadores de un repositorio de AWS
CodeCommit.

Uso de AWS Lambda con AWS CodePipeline

AWS CodePipeline es un servicio que le permite crear canalizaciones de entrega continua para
aplicaciones que se ejecutan en AWS. Puede crear una canalización para implementar la aplicación
Lambda. También puede configurar una canalización para invocar una función Lambda que realice una
tarea cuando se ejecute la canalización. Cuando crea una aplicación Lambda (p. 132) en la consola de
Lambda, Lambda crea una canalización que incluye las etapas de origen, creación e implementación.

CodePipeline invoca la función de forma asincrónica con un evento que contiene detalles sobre el
trabajo. En el ejemplo siguiente se muestra un evento de una canalización que ha invocado una función
denominada my-function.

Example Evento de CodePipeline

{
"[Link]": {
"id": "c0d76431-b0e7-xmpl-97e3-e8ee786eb6f6",
"accountId": "123456789012",
"data": {
"actionConfiguration": {
"configuration": {
"FunctionName": "my-function",
"UserParameters": "{\"KEY\": \"VALUE\"}"
}
},
"inputArtifacts": [
{

195
 AWS Lambda Guía para desarrolladores
CodePipeline

"name": "my-pipeline-SourceArtifact",
"revision": "e0c7xmpl2308ca3071aa7bab414de234ab52eea",
"location": {
"type": "S3",
"s3Location": {
"bucketName": "aws-us-west-2-123456789012-my-pipeline",
"objectKey": "my-pipeline/test-api-2/TdOSFRV"
}
}
}
],
"outputArtifacts": [
{
"name": "invokeOutput",
"revision": null,
"location": {
"type": "S3",
"s3Location": {
"bucketName": "aws-us-west-2-123456789012-my-pipeline",
"objectKey": "my-pipeline/invokeOutp/D0YHsJn"
}
}
}
],
"artifactCredentials": {
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"secretAccessKey": "6CGtmAa3lzWtV7a...",
"sessionToken": "IQoJb3JpZ2luX2VjEA...",
"expirationTime": 1575493418000
}
}
}
}

Para completar el trabajo, la función debe llamar a la API de CodePipeline para señalizar si se ha
realizado correcta o incorrectamente. En el ejemplo siguiente de función de [Link] se utiliza la operación
PutJobSuccessResult para señalizar que se ha realizado correctamente. Obtiene el ID de trabajo para
la llamada a la API desde el objeto de evento.

Example [Link]

var AWS = require('aws-sdk')

var codepipeline = new [Link]()

[Link] = async (event) => {

[Link]([Link](event, null, 2))
var jobId = event["[Link]"].id
var params = {
jobId: jobId
}
return [Link](params).promise()
}

En la invocación asincrónica, Lambda pone en cola el mensaje y, si la función devuelve un error, lo intenta
de nuevo (p. 107). Configure la función con un destino (p. 92) para conservar los eventos que la función no
puede procesar.

Para obtener más información sobre la configuración de una canalización para invocar una función
Lambda, consulte Invocar una función AWS Lambda en una canalización en la Guía del usuario de AWS
CodePipeline.

Secciones

196
 AWS Lambda Guía para desarrolladores
Permisos

• Permisos (p. 197)

• Creación de una canalización de entrega continua para una aplicación de Lambda con AWS
CodePipeline (p. 197)

Permisos
Para invocar una función, una canalización CodePipeline necesita permiso para utilizar las siguientes
operaciones de la API:

• ListFunctions (p. 543)

• InvokeFunction (p. 527)

El rol de servicio de canalizaciones predeterminado incluye estos permisos.

Para completar un trabajo, el rol necesita los siguientes permisos en su rol de ejecución (p. 32).

• codepipeline:PutJobSuccessResult
• codepipeline:PutJobFailureResult

Estos permisos se incluyen en la política administrada AwsCodePipelineCustomActionAccess.

Creación de una canalización de entrega continua

para una aplicación de Lambda con AWS
CodePipeline
Puede utilizar AWS CodePipeline para crear una canalización de entrega continua para una aplicación
de Lambda. CodePipeline combina recursos de control de código fuente, compilación e implementación
para crear una canalización que se ejecuta cada vez que se realiza un cambio en el código fuente de la
aplicación.

En este tutorial, se crean los recursos siguientes.

• Repository (Repositorio): repositorio de Git en AWS CodeCommit. Cuando se envía un cambio, la

canalización copia el código fuente en un bucket de Amazon S3 y se lo pasa al proyecto de compilación.
• Proyecto de compilación: compilación de AWS CodeBuild que obtiene el código fuente de la canalización
y empaqueta la aplicación. El código fuente incluye una especificación de compilación con comandos
que instalan las dependencias y preparan una plantilla de Modelo de aplicación sin servidor de AWS
(AWS SAM) para la implementación.
• Configuración de implementación: la etapa de implementación de la canalización define un conjunto
de acciones que toman la plantilla de AWS SAM de la salida de la compilación, crean un conjunto de
cambios en AWS CloudFormation y ejecutan el conjunto de cambios para actualizar la pila de AWS
CloudFormation de la aplicación.
• Pila de AWS CloudFormation: la etapa de implementación usa una plantilla para crear una pila en
AWS CloudFormation. La plantilla es un documento con formato YAML que define los recursos de la
aplicación de Lambda. La aplicación incluye una función de Lambda y una API de Amazon API Gateway
que la llama.
• Roles: la canalización, la compilación y la implementación tienen su propio rol de servicio que les permite
administrar los recursos de AWS. La consola crea la canalización y los roles de compilación cuando se
crean esos recursos. Usted debe crear el rol que permite a AWS CloudFormation administrar la pila de la
aplicación.

197
 AWS Lambda Guía para desarrolladores
Tutorial

La canalización asigna una única ramificación de un repositorio a una única pila de AWS CloudFormation.
Puede crear canalizaciones adicionales para agregar entornos para otras ramificaciones del mismo
repositorio. También puede añadir etapas a la canalización para pruebas, ensayo y las aprobaciones
manuales. Para obtener más información acerca de AWS CodePipeline, consulte ¿Qué es AWS
CodePipeline?.

Para conocer otra forma de crear una canalización con Modelo de aplicación sin servidor de AWS y AWS
CloudFormation, vea Automate Your Serverless Application Deployments en el canal de YouTube de
Amazon Web Services.

Secciones
• Requisitos previos (p. 198)
• Creación de un rol para AWS CloudFormation (p. 198)
• Configuración de un repositorio (p. 199)
• Creación de una canalización (p. 200)
• Actualización del rol de la etapa de compilación (p. 201)
• Finalización de la etapa de implementación (p. 202)
• Probar la aplicación (p. 202)

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Durante la fase de compilación, el script de compilación carga los artefactos en Amazon Simple Storage
Service (Amazon S3). Puede utilizar un bucket existente o crear uno nuevo para la canalización. Utilice la
AWS CLI para crear un bucket.

$ aws s3 mb s3://lambda-deployment-artifacts-123456789012

Creación de un rol para AWS CloudFormation

Cree un rol que conceda permiso a AWS CloudFormation para obtener acceso a los recursos de AWS.

Para crear un rol para AWS CloudFormation

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

198
 AWS Lambda Guía para desarrolladores
Tutorial

• Trusted entity (Entidad de confianza): AWS CloudFormation.

• Permissions (Permisos): AWSLambdaExecute.
• Role name (Nombre de rol): cfn-lambda-pipeline.
4. Abra el rol. En la pestaña Permissions (Permisos), elija Add inline policy (Añadir política insertada).
5. En Create Policy (Crear política), elija la pestaña JSON y añada la política siguiente.

{
"Statement": [
{
"Action": [
"apigateway:*",
"codedeploy:*",
"lambda:*",
"cloudformation:CreateChangeSet",
"iam:GetRole",
"iam:CreateRole",
"iam:DeleteRole",
"iam:PutRolePolicy",
"iam:AttachRolePolicy",
"iam:DeleteRolePolicy",
"iam:DetachRolePolicy",
"iam:PassRole",
"s3:GetObject",
"s3:GetObjectVersion",
"s3:GetBucketVersioning"
],
"Resource": "*",
"Effect": "Allow"
}
],
"Version": "2012-10-17"
}

Configuración de un repositorio
Creación de un repositorio de AWS CodeCommit para almacenar los archivos del proyecto. Para obtener
más información, consulte Configuración en la Guía del usuario de CodeCommit.

Para crear un repositorio

1. Abra la consola de herramientas para desarrolladores.

2. En Source (Código fuente), elija Repositories (Repositorios).
3. Elija Create repository (Crear repositorio).
4. Siga las instrucciones para crear y clonar un repositorio denominado lambda-pipeline-repo.

Cree los siguientes archivos en la carpeta del repositorio.

Example [Link]

Una función de Lambda que devuelve la hora actual.

var time = require('time');

[Link] = (event, context, callback) => {
var currentTime = new [Link]();
[Link]("America/Los_Angeles");
callback(null, {

199
 AWS Lambda Guía para desarrolladores
Tutorial

statusCode: '200',
body: 'The time in Los Angeles is: ' + [Link](),
});
};

Example [Link]
La plantilla de AWS SAM (p. 28) que define la aplicación.

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Outputs the time
Resources:
TimeFunction:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs10.x
CodeUri: ./
Events:
MyTimeApi:
Type: Api
Properties:
Path: /TimeResource
Method: GET

Example [Link]
Una especificación de compilación de AWS CodeBuild que instala los paquetes necesarios y carga el
paquete de implementación en Amazon S3. Sustituya el texto resaltado por el nombre del bucket.

version: 0.2
phases:
install:
runtime-versions:
nodejs: 10
build:
commands:
- npm install time
- export BUCKET=lambda-deployment-artifacts-123456789012
- aws cloudformation package --template-file [Link] --s3-bucket $BUCKET --
output-template-file [Link]
artifacts:
type: zip
files:
- [Link]
- [Link]

Confirme y envíe los archivos a CodeCommit.

~/lambda-pipeline-repo$ git add .

~/lambda-pipeline-repo$ git commit -m "project files"
~/lambda-pipeline-repo$ git push

Creación de una canalización

Cree una canalización que implemente la aplicación. La canalización monitoriza los cambios que se
producen en el repositorio, ejecuta una compilación de AWS CodeBuild para crear un paquete de
implementación, e implementa la aplicación con AWS CloudFormation. Durante el proceso de creación de
la canalización, también tendrá que crear el proyecto de compilación de AWS CodeBuild.

200
 AWS Lambda Guía para desarrolladores
Tutorial

Para crear una canalización

1. Abra la consola de herramientas para desarrolladores.

2. En Pipeline (Canalización), elija Pipelines (Canalizaciones).
3. Elija Create pipeline (Crear canalización).
4. Configure los ajustes de la canalización y elija Next (Siguiente).

• Pipeline name (Nombre de canalización): lambda-pipeline

• Service role (Rol de servicio): Nuevo rol de servicio (Nuevo rol de servicio)
• Artifact store (Almacén de artefactos): Default location (Ubicación predeterminada)
5. Configure los ajustes de la etapa de código fuente y elija Next (Siguiente).

• Source provider (Proveedor de código fuente): AWS CodeCommit

• Repository name (Nombre del repositorio): lambda-pipeline-repo
• Branch name (Nombre de ramificación) – master
• Change detection options (Opciones de detección de cambios): Amazon CloudWatch Events
6. En Build provider (Proveedor de compilación), elija AWS CodeBuild y, a continuación, Create project
(Crear proyecto).
7. Configure los ajustes del proyecto de compilación y elija Continue to CodePipeline (Continuar en
CodePipeline).

• Project name (Nombre de proyecto): lambda-pipeline-build

• Operating system (Sistema operativo): Ubuntu
• Runtime (Tiempo de ejecución): Standard (estándar)
• Runtime version (Versión de tiempo de ejecución): aws/codebuild/standard:2.0
• Image version (Version de la imagen): Latest (Más reciente)
• Buildspec name (Nombre de buildspec): [Link]
8. Seleccione Next (Siguiente).
9. Configure los ajustes de la etapa de implementación y elija Next (Siguiente).

• Deploy provider (Proveedor de implementación): AWS CloudFormation

• Action mode (Modo de acción): Create or replace a change set (Crear o sustituir un conjunto de
cambios)
• Stack name (Nombre de la pila): lambda-pipeline-stack
• Change set name (Nombre del conjunto de cambios): lambda-pipeline-changeset
• Template (Plantilla): BuildArtifact::[Link]
• Funcionalidades: CAPABILITY_IAM, CAPABILITY_AUTO_EXPAND
• Role name (Nombre de rol): cfn-lambda-pipeline
10. Elija Create pipeline (Crear canalización).

La canalización genera un error la primera vez que se ejecuta, ya que necesita permisos adicionales. En la
sección siguiente, añadirá permisos al rol que se genera para la fase de compilación.

Actualización del rol de la etapa de compilación

Durante la etapa de compilación, AWS CodeBuild necesita permiso para cargar la salida de la compilación
en el bucket de Amazon S3.

Para actualizar el rol

1. Abra la página Roles en la consola de IAM.

201
 AWS Lambda Guía para desarrolladores
Tutorial

2. Elija code-build-lamba-pipeline-service-role.
3. Seleccione Attach policies (Asociar políticas).
4. Asocie AmazonS3FullAccess.

Finalización de la etapa de implementación

La etapa de implementación tiene una acción que crea un conjunto de cambios para la pila de AWS
CloudFormation que administra la aplicación de Lambda. Un conjunto de cambios especifica los cambios
que se realizan en la pila como, por ejemplo, la adición de nuevos recursos y la actualización de recursos
existentes. Los conjuntos de cambios le permiten obtener una vista previa de los cambios que se realizan
antes de hacerlos y añadir las etapas de aprobación. Añada una segunda acción para ejecutar el conjunto
de cambios para completar la implementación.

Para actualizar la pila de implementación

1. Abra la canalización en la consola de herramientas para desarrolladores.

2. Elija Edit (Editar).
3. Junto a Deploy (Implementación), elija Edit stage (Editar etapa).
4. Elija Add action group (Añadir grupo de acciones).
5. Configure los ajustes de la etapa de implementación y elija Next (Siguiente).

• Action name (Nombre de acción) – execute-changeset

• Action provider (Proveedor de acciones): AWS CloudFormation
• Input artifacts (Artefactos de entrada): BuildArtifact
• Action mode (Modo de acción): Execute a change set (Ejecutar un conjunto de cambios)
• Stack name (Nombre de la pila): lambda-pipeline-stack
• Change set name (Nombre del conjunto de cambios): lambda-pipeline-changeset
6. Seleccione Listo.
7. Elija Save (Guardar).
8. Elija Release change (Publicar modificación) para ejecutar la canalización.

La canalización está lista. Envíe los cambios a la ramificación maestra para desencadenar una
implementación.

Probar la aplicación
La aplicación incluye una API de API Gateway con un punto de enlace público que devuelve la hora actual.
Utilice la consola de Lambda para ver la aplicación y obtener acceso a la API.

Para probar la aplicación

1. Abra la página Applications (Aplicaciones) de la consola de Lambda.

2. Elija lambda-pipeline-stack.
3. En Resources (Recursos), expanda ServerlessRestApi.
4. Elija Prod API endpoint (Punto de enlace de API Prod).
5. Añada /TimeResource al final de la URL. Por ejemplo, [Link]
[Link]/Prod/TimeResource.
6. Abra la URL.

La API devuelve la hora actual con el siguiente formato.

202
 AWS Lambda Guía para desarrolladores
Amazon Cognito

The time in Los Angeles is: Thu Jun 27 2019 16:07:20 GMT-0700 (PDT)

Uso de AWS Lambda con Amazon Cognito

La característica de eventos de Amazon Cognito permite ejecutar una función de Lambda como respuesta
a eventos de Amazon Cognito. Por ejemplo, puede invocar una función de Lambda para los eventos Sync
Trigger, que se publique cada vez que se sincronice un conjunto de datos. Para obtener más información y
ver un ejemplo, consulte Introducing Amazon Cognito Events: Sync Triggers en el blog de desarrollo para
móviles.

Example Evento de mensaje de Amazon Cognito

{
"datasetName": "datasetName",
"eventType": "SyncTrigger",
"region": "us-east-1",
"identityId": "identityId",
"datasetRecords": {
"SampleKey2": {
"newValue": "newValue2",
"oldValue": "oldValue2",
"op": "replace"
},
"SampleKey1": {
"newValue": "newValue1",
"oldValue": "oldValue1",
"op": "replace"
}
},
"identityPoolId": "identityPoolId",
"version": 2
}

El mapeo de orígenes de eventos de Amazon Cognito se configura mediante la configuración de

suscripciones de eventos. Para obtener información sobre el mapeo de orígenes de eventos y un evento
de muestra, consulte Eventos de Amazon Cognito en la Guía para desarrolladores de Amazon Cognito.

Uso de AWS Lambda con AWS Config

Puede utilizar funciones de AWS Lambda para evaluar si las configuraciones de los recursos de AWS
cumplen sus reglas personalizadas de AWS Config. A medida que se crean, eliminan o cambian recursos,
AWS Config registra estos cambios y envía la información a las funciones de Lambda. A continuación, las
funciones de Lambda, evalúan los cambios y envían los resultados a AWS Config. A continuación, puede
utilizar AWS Config para evaluar la conformidad general de los recursos: puede averiguar qué recursos no
son conformes y los atributos de configuración que provocan esta situación.

Example Evento de mensaje de AWS Config

{
"invokingEvent": "{\"configurationItem\":{\"configurationItemCaptureTime\":
\"2016-02-17T01:36:34.043Z\",\"awsAccountId\":\"000000000000\",\"configurationItemStatus\":
\"OK\",\"resourceId\":\"i-00000000\",\"ARN\":\"arn:aws:ec2:us-east-1:000000000000:instance/
i-00000000\",\"awsRegion\":\"us-east-1\",\"availabilityZone\":\"us-east-1a\",
\"resourceType\":\"AWS::EC2::Instance\",\"tags\":{\"Foo\":\"Bar\"},\"relationships\":
[{\"resourceId\":\"eipalloc-00000000\",\"resourceType\":\"AWS::EC2::EIP\",\"name\":

203
 AWS Lambda Guía para desarrolladores
Amazon DynamoDB

\"Is attached to ElasticIp\"}],\"configuration\":{\"foo\":\"bar\"}},\"messageType\":

\"ConfigurationItemChangeNotification\"}",
"ruleParameters": "{\"myParameterKey\":\"myParameterValue\"}",
"resultToken": "myResultToken",
"eventLeftScope": false,
"executionRoleArn": "arn:aws:iam::012345678912:role/config-role",
"configRuleArn": "arn:aws:config:us-east-1:012345678912:config-rule/config-
rule-0123456",
"configRuleName": "change-triggered-config-rule",
"configRuleId": "config-rule-0123456",
"accountId": "012345678912",
"version": "1.0"
}

Para obtener más información, consulte Evaluación de recursos con reglas de AWS Config.

Uso de AWS Lambda con Amazon DynamoDB

Puede utilizar una función AWS Lambda para procesar los registros de un flujo de Amazon DynamoDB.
Con Flujos de DynamoDB, puede activar una función de Lambda para realizar trabajo adicional cada vez
que se actualice una tabla de DynamoDB.

Lambda lee los registros del flujo e invoca la función de forma síncrona (p. 88) con un evento que contiene
los registros del flujo. Lambda lee los registros por lotes e invoca la función para procesar los registros de
cada lote.

Example Flujos de DynamoDB Evento de registro.

{
"Records": [
{
"eventID": "1",
"eventVersion": "1.0",
"dynamodb": {
"Keys": {
"Id": {
"N": "101"
}
},
"NewImage": {
"Message": {
"S": "New item!"
},
"Id": {
"N": "101"
}
},
"StreamViewType": "NEW_AND_OLD_IMAGES",
"SequenceNumber": "111",
"SizeBytes": 26
},
"awsRegion": "us-west-2",
"eventName": "INSERT",
"eventSourceARN": eventsourcearn,
"eventSource": "aws:dynamodb"
},
{
"eventID": "2",
"eventVersion": "1.0",
"dynamodb": {
"OldImage": {

204
 AWS Lambda Guía para desarrolladores
Amazon DynamoDB

"Message": {
"S": "New item!"
},
"Id": {
"N": "101"
}
},
"SequenceNumber": "222",
"Keys": {
"Id": {
"N": "101"
}
},
"SizeBytes": 59,
"NewImage": {
"Message": {
"S": "This item has changed"
},
"Id": {
"N": "101"
}
},
"StreamViewType": "NEW_AND_OLD_IMAGES"
},
"awsRegion": "us-west-2",
"eventName": "MODIFY",
"eventSourceARN": sourcearn,
"eventSource": "aws:dynamodb"
}

Lambda sondea las particiones del flujo de DynamoDB y busca registros 4 veces por segundo. Cuando
hay registros disponibles, Lambda invoca la función y espera el resultado. Si el procesamiento se realiza
correctamente, Lambda reanuda el sondeo hasta que recibe más registros.

De forma predeterminada, Lambda llama a su función en cuanto los registros están disponibles en el flujo.
Si el lote que lee desde el flujo solo tiene un registro, Lambda solo envía un registro a la función. Para
evitar invocar a la función con un número de registros pequeño, puede indicar al origen del evento que
almacene en búfer registros durante hasta 5 minutos configurando una ventana de lote. Antes de invocar
a la función, Lambda sigue leyendo registros desde el flujo hasta que haya recopilado un lote completo o
hasta que caduca la ventana de lote.

Si la función devuelve un error, Lambda volverá a intentar ejecutar el lote hasta que el procesamiento
se realice correctamente o los datos caduquen. Para evitar particiones detenidas, puede configurar la
asignación del origen de eventos para que vuelva a intentarlo con un tamaño de lote menor, para que limite
el número de reintentos o para que se descarten los registros que sean muy antiguos. Si desea conservar
los eventos descartados, puede configurar la asignación del origen de eventos para que envíe información
sobre los lotes con errores a una cola de SQS o un tema de SNS.

También puede aumentar la simultaneidad procesando varios lotes de cada partición en paralelo. Lambda
puede procesar hasta 10 lotes en cada partición simultáneamente. Si aumenta el número de lotes
simultáneos en cada partición, Lambda seguirá garantizando que el procesamiento se realiza en orden en
el nivel de la clave de partición.

Secciones
• Permisos de rol de ejecución (p. 206)
• Configuración de una secuencia como un origen de eventos (p. 206)
• API de mapeo de origen de eventos (p. 207)
• Control de errores (p. 209)
• Métricas de Amazon CloudWatch (p. 210)
• Tutorial: Usar de AWS Lambda con flujos de Amazon DynamoDB. (p. 210)

205
 AWS Lambda Guía para desarrolladores
Permisos de rol de ejecución

• Código de función de muestra (p. 214)

• Plantilla de AWS SAM para una aplicación de DynamoDB (p. 217)

Permisos de rol de ejecución

Lambda necesita los siguientes permisos para administrar los recursos relacionados con el flujo de
DynamoDB. Añada dichos permisos al rol de ejecución de su función.

• dynamodb:DescribeStream
• dynamodb:GetRecords
• dynamodb:GetShardIterator
• dynamodb:ListStreams

La política administrada AWSLambdaDynamoDBExecutionRole contiene los permisos siguientes: Para

obtener más información, consulte Rol de ejecución de AWS Lambda (p. 32).

Para enviar registros de un lote con errores a una cola o un tema, la función necesita permisos adicionales.
Cada servicio de destino requiere un permiso diferente, como se indica a continuación:

• Amazon SQS: sqs:SendMessage

• Amazon SNS: sns:Publish

Configuración de una secuencia como un origen de

eventos
Cree un mapeo de origen de eventos para indicar a Lambda que envíe registros desde un flujo a una
función de Lambda. Puede crear varios mapeos de orígenes de eventos para procesar los mismos datos
con distintas funciones de Lambda o para procesar elementos de varios flujos con una sola función.

Para configurar la función para que lea desde Flujos de DynamoDB en la consola de Lambda, cree un
desencadenador de DynamoDB.

Para crear un disparador

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add trigger (Añadir disparador).
4. Elija un tipo de disparador.
5. Configure las opciones necesarias y, a continuación, elija Add (Añadir).

Lambda admite las siguientes opciones para los orígenes de eventos de DynamoDB.

Opciones de origen de eventos

• DynamoDB table (Tabla DynamoDB): la tabla de DynamoDB de la que leer registros.

• Batch size (Tamaño del lote): número de registros que hay que enviar a la función en cada lote,
hasta 1000. Lambda pasa todos los registros del lote a la función en una sola llamada, siempre que el
tamaño total de los eventos no supere el límite de carga (p. 30) para la invocación asíncrona (6 MB).
• Batch window (Ventana de lote): especifique la cantidad de tiempo máxima para recopilar registros antes
de invocar la función, en segundos.

206
 AWS Lambda Guía para desarrolladores
API de mapeo de origen de eventos

• Starting position (Posición inicial): procesar solo los registros nuevos o todos los registros existentes.
• Latest (Más recientes): procesar los registros nuevos que se añaden al flujo principal.
• Trim horizon (Horizonte de supresión): procesar todos los registros del flujo.

Tras procesar cualquier registro existente, la función es alcanzada y continúa procesando registros
nuevos.
• On-failure destination (Destino en caso de error): cola de SQS o tema de SNS de los registros que no
pueden procesarse. Cuando Lambda descarta un lote de registros porque es demasiado antiguo o se
han agotado todos los reintentos, envía información sobre el lote a la cola o al tema.
• Retry attempts (Número de reintentos): número máximo de reintentos que Lambda realiza cuando la
función devuelve un error. No se aplica a los errores ni las limitaciones de los servicios en los que el lote
no alcanza la función.
• Maximum age of record (Antigüedad máxima del registro): antigüedad máxima de un registro que
Lambda envía a la función.
• Split batch on error (Dividir lote en caso de error): cuando la función devuelve un error, el lote se divide
en dos antes de intentarlo de nuevo.
• Process multiple batches from the same shard concurrently (Lotes simultáneos por partición): procesa
simultáneamente varios lotes de la misma partición.
• Enabled (Habilitado): desactivar el origen de eventos para dejar de procesar registros. Lambda toma
nota del último registro procesado y sigue procesando desde ese punto cuando se habilita de nuevo el
mapeo.

Para administrar la configuración de origen de evento más tarde, elija el desencadenador en el diseñador.

API de mapeo de origen de eventos

Para administrar las asignaciones de orígenes de eventos con la AWS CLI o el SDK de AWS, utilice las
siguientes acciones de la API:

• CreateEventSourceMapping (p. 460)

• ListEventSourceMappings (p. 537)
• GetEventSourceMapping (p. 496)
• UpdateEventSourceMapping (p. 592)
• DeleteEventSourceMapping (p. 477)

En el siguiente ejemplo se utiliza la AWS CLI para asignar una función llamada my-function a una
secuencia de DynamoDB especificada mediante un nombre de recurso de Amazon (ARN), con un tamaño
de lote de 500.

$ aws lambda create-event-source-mapping --function-name my-function --batch-size 500 --

starting-position LATEST \
--event-source-arn arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525
{
"UUID": "14e0db71-5d35-4eb5-b481-8945cf9d10c2",
"BatchSize": 500,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1560209851.963,
"LastProcessingResult": "No records processed",

207
 AWS Lambda Guía para desarrolladores
API de mapeo de origen de eventos

"State": "Creating",
"StateTransitionReason": "User action",
"DestinationConfig": {},
"MaximumRecordAgeInSeconds": 604800,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 10000
}

Configure otras opciones para personalizar el modo en que se procesan los lotes y especificar cuándo
deben descargarse los registros que no se pueden procesar. En el siguiente ejemplo, se actualiza la
asignación de un origen de eventos para enviar un registro de error a una cola de SQS después de dos
reintentos o si los registros tienen más de una hora de antigüedad.

$ aws lambda update-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \

--maximum-retry-attempts 2 --maximum-record-age-in-seconds 3600
--destination-config '{"OnFailure": {"Destination": "arn:aws:sqs:us-
east-2:123456789012:dlq"}}'
{
"UUID": "f89f8514-cdd9-4602-9e1f-01a5b77d449b",
"BatchSize": 100,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1573243620.0,
"LastProcessingResult": "PROBLEM: Function call failed",
"State": "Updating",
"StateTransitionReason": "User action",
"DestinationConfig": {},
"MaximumRecordAgeInSeconds": 604800,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 10000
}

La configuración actualizada se aplica de forma asincrónica y no se refleja en la salida hasta que se

completa el proceso. Utilice el comando get-event-source-mapping para ver el estado actual.

$ aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b

{
"UUID": "f89f8514-cdd9-4602-9e1f-01a5b77d449b",
"BatchSize": 100,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:dynamodb:us-east-2:123456789012:table/my-table/
stream/2019-06-10T19:26:16.525",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1573244760.0,
"LastProcessingResult": "PROBLEM: Function call failed",
"State": "Enabled",
"StateTransitionReason": "User action",
"DestinationConfig": {
"OnFailure": {
"Destination": "arn:aws:sqs:us-east-2:123456789012:dlq"
}
},
"MaximumRecordAgeInSeconds": 3600,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 2
}

Para procesar varios lotes simultáneamente, utilice la opción --parallelization-factor.

208
 AWS Lambda Guía para desarrolladores
Control de errores

$ aws lambda update-event-source-mapping --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 \

--parallelization-factor 5

Control de errores
La asignación del origen de eventos que lee los registros de la secuencia de DynamoDB invoca la función
de forma sincrónica y reintenta la operación si se producen errores. Si la función se ve limitada o el servicio
de Lambda devuelve un error sin invocar la función, Lambda vuelve a intentarlo hasta que el registro expira
o supera la antigüedad máxima establecida en la asignación del origen de eventos.

Si la función recibe los registros pero devuelve un error, Lambda lo vuelve a intentar hasta que vencen los
registros del lote, se supera la antigüedad máxima o se alcanza el límite de reintentos especificado. En el
caso de los errores de funciones, también puede configurar la asignación del origen de eventos para que
divida en dos los lotes que presentan errores. Al intentarlo con lotes más pequeños, se aíslan los registros
erróneos y se solucionan problemas relacionadas con el tiempo de espera. Los lotes divididos no se tienen
en cuenta para calcular el límite de reintentos.

Si las medidas de administración de errores no funcionan, Lambda descarta los registros y sigue
procesando los lotes de la secuencia. Con la configuración predeterminada, esto significa que un registro
erróneo puede bloquear el procesamiento de la partición afectada durante un máximo de one day. Para
evitar esto, configure la asignación del origen de eventos de la función con un número razonable de
reintentos y una antigüedad de registro máxima que se ajuste a su caso de uso.

Para mantener un registro de los lotes descartados, configure un destino de evento fallido. Lambda enviará
un documento a la cola o al tema de destino con información sobre el lote.

Para configurar un destino para registros de eventos con errores

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add destination (Añadir destino).
4. En Source (Origen), elija Stream invocation (Invocación por secuencias).
5. En Stream (Secuencia), elija una secuencia que esté asignada a la función.
6. En Destination type (Tipo de destino), elija el tipo de recurso que recibe el registro de invocación.
7. En Destination (Destino), elija un recurso.
8. Elija Save (Guardar).

El siguiente ejemplo muestra un registro de invocación para un flujo de DynamoDB.

Example Registro de invocación

{
"requestContext": {
"requestId": "316aa6d0-8154-xmpl-9af7-85d5f4a6bc81",
"functionArn": "arn:aws:lambda:us-east-2:123456789012:function:myfunction",
"condition": "RetryAttemptsExhausted",
"approximateInvokeCount": 1
},
"responseContext": {
"statusCode": 200,
"executedVersion": "$LATEST",
"functionError": "Unhandled"
},
"version": "1.0",
"timestamp": "2019-11-14T00:13:49.717Z",
"DDBStreamBatchInfo": {

209
 AWS Lambda Guía para desarrolladores
Métricas de Amazon CloudWatch

"shardId": "shardId-00000001573689847184-864758bb",
"startSequenceNumber": "800000000003126276362",
"endSequenceNumber": "800000000003126276362",
"approximateArrivalOfFirstRecord": "2019-11-14T00:13:19Z",
"approximateArrivalOfLastRecord": "2019-11-14T00:13:19Z",
"batchSize": 1,
"streamArn": "arn:aws:dynamodb:us-east-2:123456789012:table/mytable/
stream/2019-11-14T00:04:06.388"
}
}

Puede utilizar esta información para recuperar los registros afectados de la secuencia y solucionar los
problemas. Los registros reales no están incluidos, por lo que debe procesar este registro y recuperarlos
de la secuencia antes de que venzan y se pierdan.

Métricas de Amazon CloudWatch

Lambda emite la métrica IteratorAge cuando la función termina de procesar un lote de registros.
La métrica indica la antigüedad del último registro del lote cuando acabo el proceso. Si la función está
procesando nuevos eventos, puede utilizar la antigüedad del iterador para estimar la latencia entre el
momento en que se añade un registro y el momento en que la función lo procesa.

Una tendencia ascendente en la antigüedad del iterador puede indicar problemas con la función. Para
obtener más información, consulte Trabajar con métricas de función de AWS Lambda (p. 400).

Tutorial: Usar de AWS Lambda con flujos de Amazon

DynamoDB.
En este tutorial, se crea una función de Lambda para consumir eventos de un flujo de Amazon DynamoDB.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).

210
 AWS Lambda Guía para desarrolladores
Tutorial

3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza): Lambda.

• Permisos – AWSLambdaDynamoDBExecutionRole.
• Role name (Nombre de rol): lambda-dynamodb-role.

El AWSLambdaDynamoDBExecutionRole (Rol de ejecución Dynamo DB de AWS Lambda) tiene los

permisos que la función necesita para leer elementos desde DynamoDB y escribir registros al CloudWatch
Logs.

Creación de la función
A continuación se muestra código de ejemplo que recibe un evento de DynamoDB como entrada y procesa
los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 214).

Example [Link]

[Link]('Loading function');

[Link] = function(event, context, callback) {

[Link]([Link](event, null, 2));
[Link](function(record) {
[Link]([Link]);
[Link]([Link]);
[Link]('DynamoDB Record: %j', [Link]);
});
callback(null, "message");
};

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name ProcessDynamoDBRecords \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-dynamodb-role

Pruebe la función Lambda.

En este paso, invocará la función de Lambda manualmente mediante el comando invoke de la CLI de
AWS Lambda y el siguiente evento de muestra de DynamoDB.

Example [Link]

{
"Records":[

211
 AWS Lambda Guía para desarrolladores
Tutorial

{
"eventID":"1",
"eventName":"INSERT",
"eventVersion":"1.0",
"eventSource":"aws:dynamodb",
"awsRegion":"us-east-1",
"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"NewImage":{
"Message":{
"S":"New item!"
},
"Id":{
"N":"101"
}
},
"SequenceNumber":"111",
"SizeBytes":26,
"StreamViewType":"NEW_AND_OLD_IMAGES"
},
"eventSourceARN":"stream-ARN"
},
{
"eventID":"2",
"eventName":"MODIFY",
"eventVersion":"1.0",
"eventSource":"aws:dynamodb",
"awsRegion":"us-east-1",
"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"NewImage":{
"Message":{
"S":"This item has changed"
},
"Id":{
"N":"101"
}
},
"OldImage":{
"Message":{
"S":"New item!"
},
"Id":{
"N":"101"
}
},
"SequenceNumber":"222",
"SizeBytes":59,
"StreamViewType":"NEW_AND_OLD_IMAGES"
},
"eventSourceARN":"stream-ARN"
},
{
"eventID":"3",
"eventName":"REMOVE",
"eventVersion":"1.0",
"eventSource":"aws:dynamodb",
"awsRegion":"us-east-1",

212
 AWS Lambda Guía para desarrolladores
Tutorial

"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"OldImage":{
"Message":{
"S":"This item has changed"
},
"Id":{
"N":"101"
}
},
"SequenceNumber":"333",
"SizeBytes":38,
"StreamViewType":"NEW_AND_OLD_IMAGES"
},
"eventSourceARN":"stream-ARN"
}
]
}

Ejecute el siguiente comando invoke.

$ aws lambda invoke --function-name ProcessDynamoDBRecords --payload [Link]

[Link]

La función devuelve la cadena message en el cuerpo de la respuesta.

Verifique la salida en el archivo [Link].

Crear una tabla DynamoDB con una secuencia habilitada

Crear una tabla de Amazon DynamoDB con un flujo habilitado.

Para crear una tabla de DynamoDB

1. Abra la consola de DynamoDB.

2. Seleccione Create table.
3. Cree una tabla con la siguiente configuración:

• Nombre de la tabla – lambda-dynamodb-stream

• Primary key (Clave principal) – id (cadena)
4. Seleccione Create.

Habilitar secuencias

1. Abra la consola de DynamoDB.

2. Elija Tables (Tablas).
3. Elija la tabla lambda-dynamodb-stream (Flujo de dynamodb lambda).
4. En la pestaña Información general, elija Administrar flujo.
5. Elija Enable.

Anote el ARN del flujo. Lo necesitará en el siguiente paso al asociar el flujo a la función de Lambda. Para
obtener más información acerca de cómo habilitar flujos, consulte Captura de la actividad de las tablas con
flujos de DynamoDB.

213
 AWS Lambda Guía para desarrolladores
Código de muestra

Adición de un origen de evento en AWS Lambda

Crear un mapeo de origen de eventos en AWS Lambda. Este mapeo de origen de eventos asocia el flujo
de DynamoDB a la función de Lambda. Una vez creado este mapeo de origen de eventos, AWS Lambda
comienza a sondear el flujo.

Ejecute el comando siguiente AWS CLI create-event-source-mapping. Una vez ejecutado el

comando, anote el UUID. Necesitará este UUID para hacer referencia al mapeo de origen de eventos en
los comandos, por ejemplo, al eliminar el mapeo de origen de eventos.

$ aws lambda create-event-source-mapping --function-name ProcessDynamoDBRecords \

--batch-size 100 --starting-position LATEST --event-source DynamoDB-stream-arn

Esto crea un mapeo entre el flujo de DynamoDB especificado y la función de Lambda. Puede asociar
un flujo de DynamoDB a varias funciones de Lambda, así como asociar la misma función de Lambda a
varios flujos. Sin embargo, las funciones de Lambda compartirán el desempeño de lectura para el flujo que
comparten.

Para obtener la lista de mapeos de orígenes de eventos, ejecute el siguiente comando.

$ aws lambda list-event-source-mappings

La lista devuelve todos los mapeos de orígenes de eventos creados, y para cada uno de ellos muestra
el LastProcessingResult, entre otras cosas. Este campo se utiliza para proporcionar un mensaje
informativo en caso de que surja algún problema. Los valores como No records processed (indica
que AWS Lambda no ha comenzado el sondeo o que no hay registros en el flujo) y OK (indica que AWS
Lambda ha leído correctamente los registros del flujo y ha invocado la función de Lambda) indican que no
hay ningún problema. Si hay algún problema, recibirá un mensaje de error.

Si tiene muchos mapeos de origen de eventos, use la función nombrar parámetro para reducir los
resultados.

$ aws lambda list-event-source-mappings --function-name ProcessDynamoDBRecords

Prueba de la configuración
Probar la experiencia integral. A medida que se actualiza la tabla, DynamoDB escribe los registros de
eventos en el flujo. AWS Lambda sondea el flujo, detecta nuevos registros en él y ejecuta la función de
Lambda en nombre del usuario pasando eventos a esta.

1. En la consola de DynamoDB, añada, actualice y elimine elementos de la tabla. DynamoDB escribe

registros de estas acciones en el flujo.
2. AWS Lambda sondea el flujo y, cuando detecta actualizaciones en este, invoca la función de Lambda
pasando los datos de eventos que encuentra en el flujo.
3. La función ejecuta y crea registros en Amazon CloudWatch. Puede verificar los registros reportados en
la consola de Amazon CloudWatch.

Código de función de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• [Link] (p. 215)

214
 AWS Lambda Guía para desarrolladores
Código de muestra

• Java 11 (p. 215)

• C# (p. 216)
• Python 3 (p. 217)
• Go (p. 217)

[Link]
En el siguiente ejemplo, se procesan los mensajes de DynamoDB, y registra su contenido.

Example [Link]

[Link]('Loading function');

exports.lambda_handler = function(event, context, callback) {

[Link]([Link](event, null, 2));
[Link](function(record) {
[Link]([Link]);
[Link]([Link]);
[Link]('DynamoDB Record: %j', [Link]);
});
callback(null, "message");
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

Java 11
El siguiente ejemplo procesa mensajes desde DynamoDB y registra sus contenidos. handleRequest es
el controlador que AWS Lambda invoca y proporciona datos de evento. Este controlador utiliza la clase
DynamodbEvent predefinida, que se define en la biblioteca aws-lambda-java-events.

Example [Link]

package example;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class DDBEventProcessor implements

RequestHandler<DynamodbEvent, String> {

public String handleRequest(DynamodbEvent ddbEvent, Context context) {

for (DynamodbStreamRecord record : [Link]()){
[Link]([Link]());
[Link]([Link]());
[Link]([Link]().toString());

}
return "Successfully processed " + [Link]().size() + " records.";
}
}

Si el controlador vuelve normalmente sin excepciones, Lambda considera que el lote de registros de
entrada se ha procesado correctamente y empieza a leer nuevos registros en el flujo. Si el controlador

215
 AWS Lambda Guía para desarrolladores
Código de muestra

genera una excepción, Lambda considera que el lote de registros de entrada no se ha procesado e invoca
de nuevo la función con el mismo lote de registros.

Dependencias.

• aws-lambda-java-core
• aws-lambda-java-events

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

C#
El siguiente ejemplo procesa mensajes desde DynamoDB y registra sus contenidos.
ProcessDynamoEvent es el controlador que AWS Lambda invoca y proporciona datos de evento.
Este controlador utiliza la clase DynamoDbEvent predefinida, que se define en la biblioteca
[Link].

Example [Link]

using System;
using [Link];
using [Link];
using [Link];
using [Link];

using [Link];

namespace DynamoDBStreams
{
public class DdbSample
{
private static readonly JsonSerializer _jsonSerializer = new JsonSerializer();

public void ProcessDynamoEvent(DynamoDBEvent dynamoEvent)

{
[Link]($"Beginning to process {[Link]}
records...");

foreach (var record in [Link])

{
[Link]($"Event ID: {[Link]}");
[Link]($"Event Name: {[Link]}");

string streamRecordJson = SerializeObject([Link]);

[Link]($"DynamoDB Record:");
[Link](streamRecordJson);
}

[Link]("Stream processing complete.");

}

private string SerializeObject(object streamRecord)

{
using (var ms = new MemoryStream())
{
_jsonSerializer.Serialize(streamRecord, ms);
return [Link]([Link]());
}
}
}

216
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

Reemplace [Link] en un proyecto .NET Core con el ejemplo anterior. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en C# (p. 372).

Python 3
En el siguiente ejemplo, se procesan los mensajes de DynamoDB, y registra su contenido.

Example [Link]

from __future__ import print_function

def lambda_handler(event, context):

for record in event['Records']:
print(record['eventID'])
print(record['eventName'])
print('Successfully processed %s records.' % str(len(event['Records'])))

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Go
En el siguiente ejemplo, se procesan los mensajes de DynamoDB, y registra su contenido.

Example

import (
"strings"

"[Link]/aws/aws-lambda-go/events"
)

func handleRequest(ctx [Link], e [Link]) {

for _, record := range [Link] {

[Link]("Processing request data for event ID %s, type %s.\n", [Link],
[Link])

// Print new values for attributes of type String

for name, value := range [Link] {
if [Link]() == [Link] {
[Link]("Attribute name: %s, value: %s\n", name, [Link]())
}
}
}
}

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Plantilla de AWS SAM para una aplicación de

DynamoDB
Puede construir esta aplicación utilizando AWS SAM. Para obtener más información sobre la creación
de plantillas AWS SAM, diríjase a AWS SAM Aspectos básicos sobre plantillas en la Guía para
desarrolladores deModelo de aplicación sin servidor de AWS.

217
 AWS Lambda Guía para desarrolladores
Amazon ElastiCache

A continuación, hay una plantilla AWS SAM de muestra para la aplicación del tutorial (p. 210). Copie el
texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha creado anteriormente. Tenga en
cuenta que los valores de los parámetros Handler y Runtime deben coincidir con los que utilizó cuando
creó la función en la sección anterior.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
ProcessDynamoDBStream:
Type: AWS::Serverless::Function
Properties:
Handler: handler
Runtime: runtime
Policies: AWSLambdaDynamoDBExecutionRole
Events:
Stream:
Type: DynamoDB
Properties:
Stream: !GetAtt [Link]
BatchSize: 100
StartingPosition: TRIM_HORIZON

DynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: id
AttributeType: S
KeySchema:
- AttributeName: id
KeyType: HASH
ProvisionedThroughput:
ReadCapacityUnits: 5
WriteCapacityUnits: 5
StreamSpecification:
StreamViewType: NEW_IMAGE

Para obtener más informaciónsobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

Tutorial: Configuración de una función de Lambda

para obtener acceso a Amazon ElastiCache en una
Amazon VPC
En este tutorial, aprenderá a hacer lo siguiente:

• Crar un clúster de Amazon ElastiCache en su Amazon Virtual Private Cloud predeterminada. Para
obtener más información acerca de Amazon ElastiCache, consulte Amazon ElastiCache.
• Crear una función de Lambda para obtener acceso al clúster de ElastiCache. Al crear la función de
Lambda debe proporcionar los ID de subred de Amazon VPC, así como un grupo de seguridad de VPC
para que la función de Lambda pueda obtener acceso a los recursos de la VPC. En este tutorial, con
fines ilustrativos, la función de Lambda genera un UUID, lo escribe en la caché y lo recupera de esta.

218
 AWS Lambda Guía para desarrolladores
Requisitos previos

• Invoque la función de Lambda manualmente y verifique que ha tenido acceso al clúster de ElastiCache
de la VPC.

Para obtener más información sobre el uso de Lambda con Amazon VPC, consulte Configuración de una
función Lambda para obtener acceso a los recursos en una VPC (p. 78).

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza): Lambda.

• Permissions (Permisos) – AWSLambdaVPCAccessExecutionRole.
• Role name (Nombre de rol): lambda-vpc-role.

El AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para administrar las

conexiones de red a una VPC.

Crear un clúster de ElastiCache.

Cree un clúster de ElastiCache en su VPC predeterminada.

1. Ejecute el siguiente comando de la AWS CLI; para crear un clúster de Memcached.

$ aws elasticache create-cache-cluster --cache-cluster-id ClusterForLambdaTest \

--cache-node-type [Link] --engine memcached --num-cache-nodes 1 \
--security-group-ids sg-0897d5f549934c2fb

Puede buscar el grupo de seguridad de VPC predeterminado en la consola de VPC en Security

Groups. La función de Lambda de ejemplo añadirá y recuperará un elemento de este clúster.

219
 AWS Lambda Guía para desarrolladores
Cree un paquete de implementación.

2. Anote el punto de enlace de configuración para el clúster de caché que ha lanzado. Puede obtenerlo
de la consola de Amazon ElastiCache. Especificará este valor en el código de la función de Lambda
en la siguiente sección.

Cree un paquete de implementación.

El siguiente ejemplo de código de Python lee y escribe un elemento en el clúster de ElastiCache.

Example [Link]

from __future__ import print_function

import time
import uuid
import sys
import socket
import elasticache_auto_discovery
from [Link] import HashClient

#elasticache settings
elasticache_config_endpoint = "your-elasticache-cluster-endpoint:port"
nodes = elasticache_auto_discovery.discover(elasticache_config_endpoint)
nodes = map(lambda x: (x[1], int(x[2])), nodes)
memcache_client = HashClient(nodes)

def handler(event, context):

"""
This function puts into memcache and get from it.
Memcache is hosted using elasticache
"""

#Create a random UUID... this will be the sample element we add to the cache.
uuid_inserted = uuid.uuid4().hex
#Put the UUID to the cache.
memcache_client.set('uuid', uuid_inserted)
#Get item (UUID) from the cache.
uuid_obtained = memcache_client.get('uuid')
if uuid_obtained.decode("utf-8") == uuid_inserted:
# this print should go to the CloudWatch Logs and Lambda console.
print ("Success: Fetched value %s from memcache" %(uuid_inserted))
else:
raise Exception("Value is not the same as we put :(. Expected %s got %s"
%(uuid_inserted, uuid_obtained))

return "Fetched value from memcache: " + uuid_obtained.decode("utf-8")

Dependencias.

• pymemcache – El código de función de Lambda utiliza esta biblioteca para crear un HashClient objeto
para enviar y recibir elementos de un memcache.
• elasticache-auto-discovery – La función de Lambda usa esta biblioteca para recibir los nodos del clúster
Amazon ElastiCache.

Instale dependencias con Pip y cree un paquete de implementación. Para obtener instrucciones, consulte
Paquete de implementación de AWS Lambda en Python (p. 304).

Creación de la función Lambda

Cree la función de Lambda con el comando create-function.

220
 AWS Lambda Guía para desarrolladores
Pruebe la función Lambda.

$ aws lambda create-function --function-name AccessMemCache --timeout 30 --memory-size 1024

\
--zip-file fileb://[Link] --handler [Link] --runtime python3.8 \
--role arn:aws:iam::123456789012:role/lambda-vpc-role \
--vpc-config SubnetIds=subnet-0532bb6758ce7c71f,subnet-
d6b7fda068036e11f,SecurityGroupIds=sg-0897d5f549934c2fb

Puede encontrar los ID de subred y el ID del grupo de seguridad predeterminado de la VPC en la consola
de VPC.

Pruebe la función Lambda.

En este paso, invocará la función de Lambda manualmente utilizando el comando invoke. Cuando la
función de Lambda se ejecuta, genera un UUID y lo escribe en el clúster de ElastiCache especificado en el
código de la función de Lambda. A continuación, la función de Lambda recupera el elemento de la caché.

1. Invoque la función de Lambda con el comando invoke.

$ aws lambda invoke --function-name AccessMemCache [Link]

2. Compruebe que la función de Lambda se ha ejecutado correctamente del modo siguiente:

• Revise el archivo [Link].

• Revise los resultados en la consola de AWS Lambda.
• Verifique los resultados en CloudWatch Logs.

Ahora que ha creado una función de Lambda que tiene acceso a un clúster de ElastiCache en la VPC,
puede hacer que la función se invoque en respuesta a eventos. Para obtener información acerca de
la configuración de orígenes de eventos y ver ejemplos, consulte Uso de AWS Lambda con otros
servicios (p. 153).

Uso de AWS Lambda con Amazon EC2

Puede utilizar AWS Lambda para procesar eventos del ciclo de vida desde Amazon Elastic Compute
Cloud y administrar recursos de Amazon EC2. Amazon EC2 envía eventos a Amazon CloudWatch
Events para eventos del ciclo de vida, como cuando una instancia cambia de estado, cuando se completa
una instantánea de volumen de Amazon Elastic Block Store o cuando se programa que se termine una
instancia de spot. Configure Eventos de CloudWatch para reenviar esos eventos a una función de Lambda
para su procesamiento.

Eventos de CloudWatch invoca su función de Lambda de forma asíncrona con el documento de evento de
Amazon EC2.

Example Ciclo de vida de la instancia

{
"version": "0",
"id": "b6ba298a-7732-2226-xmpl-976312c1a050",
"detail-type": "EC2 Instance State-change Notification",
"source": "aws.ec2",
"account": "123456798012",
"time": "2019-10-02T17:59:30Z",
"region": "us-east-2",
"resources": [
"arn:aws:ec2:us-east-2:123456798012:instance/i-0c314xmplcd5b8173"

221
 AWS Lambda Guía para desarrolladores
Permisos

],
"detail": {
"instance-id": "i-0c314xmplcd5b8173",
"state": "running"
}
}

Para obtener información detallada sobre la configuración de eventos en Eventos de CloudWatch, consulte
Uso de AWS Lambda con Amazon CloudWatch Events (p. 185). Para ver una función de ejemplo que
procesa las notificaciones de instantáneas de Amazon EBS, consulte Amazon CloudWatch Events para
Amazon EBS en Guía del usuario de Amazon EC2 para instancias de Linux.

También puede utilizar AWS SDK para administrar instancias y otros recursos con la API de Amazon EC2.
Para ver un tutorial con una aplicación de ejemplo en C#, consulte Tutorial: uso de AWS SDK para .NET
para administrar instancias de spot de Amazon EC2 (p. 222).

Permisos
Para procesar eventos del ciclo de vida desde Amazon EC2, Eventos de CloudWatch necesita permiso
para invocar su función. Este permiso proviene de la política basada en recursos (p. 36) de la función. Si
utiliza la consola de Eventos de CloudWatch para configurar un desencadenador de eventos, la consola
actualiza la directiva basada en recursos en su nombre. De lo contrario, agregue una declaración como la
siguiente:

Example Declaración de política basada en recursos para notificaciones del ciclo de vida de
Amazon EC2

{
"Sid": "ec2-events",
"Effect": "Allow",
"Principal": {
"Service": "[Link]"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:12456789012:function:my-function",
"Condition": {
"ArnLike": {
"AWS:SourceArn": "arn:aws:events:us-east-2:12456789012:rule/*"
}
}
}

Para agregar una instrucción, utilice el comando de la AWS CLI add-permission.

aws lambda add-permission --action lambda:InvokeFunction --statement-id ec2-events \

--principal [Link] --function-name my-function --source-arn
'arn:aws:events:us-east-2:12456789012:rule/*'

Si la función utiliza el SDK de AWS para administrar recursos de Amazon EC2, agregue permisos de
Amazon EC2 al rol de ejecución (p. 32) de la función.

Tutorial: uso de AWS SDK para .NET para administrar

instancias de spot de Amazon EC2
Puede usar AWS SDK para .NET para administrar instancias de spot de Amazon EC2 con código C#. El
SDK le permite utilizar la API de Amazon EC2 para crear solicitudes de instancias de spot, determinar
cuándo se cumple la solicitud, eliminar solicitudes e identificar las instancias creadas.

222
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

Este tutorial proporciona código que realiza estas tareas y una aplicación de ejemplo que puede ejecutar
localmente o en AWS. Incluye un proyecto de ejemplo que puede implementar en el tiempo de ejecución
de .NET Core 2.1 de AWS Lambda.

Para obtener más información sobre el uso de instancias de spot y prácticas recomendadas, consulte
Instancias de spot en la guía de usuario de Amazon EC2.

Requisitos previos
Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

223
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

Este tutorial utiliza código del repositorio de GitHub de la guía para desarrolladores. El repositorio también
contiene scripts auxiliares y archivos de configuración necesarios para seguir sus procedimientos. Clone el
repositorio en [Link]/awsdocs/aws-lambda-developer-guide.

Para usar el código de muestra necesita las siguientes herramientas:

• AWS CLI: para implementar la aplicación de muestra en AWS, instale la AWS CLI. La AWS CLI también
proporciona credenciales al código de muestra cuando se ejecuta localmente.
• CLI de .NET Core: para ejecutar y probar el código localmente, instale .NET Core SDK 2.1.
• Herramienta global de .NET Core de Lambda: para crear el paquete de implementación para Lambda,
instale la Herramienta global de .NET Core con la CLI de .NET Core.

$ dotnet tool install -g [Link]

El código de este tutorial administra las solicitudes de spot que lanzan instancias Amazon EC2. Para
ejecutar el código localmente, necesita credenciales de SDK con permiso para usar las siguientes API.

• ec2:RequestSpotInstance
• ec2:GetSpotRequestState
• ec2:CancelSpotRequest
• ec2:TerminateInstances

Para ejecutar la aplicación de ejemplo en AWS, necesita permiso para usar Lambda (p. 32) y los siguientes
servicios.

• AWS CloudFormation (precios)

• Amazon Elastic Compute Cloud (precios)

Se aplican cargos estándar por cada servicio.

Revise el código
Localice el proyecto de ejemplo en el repositorio de guías en sample-apps/ec2-spot. Este directorio
contiene código de función de Lambda, pruebas, archivos de proyecto, scripts y una plantilla de AWS
CloudFormation.

La clase Function incluye un método FunctionHandler que llama a otros métodos para crear
solicitudes de spot, comprobar su estado y limpiar. Crea un cliente Amazon EC2 con el AWS SDK
para .NET en un constructor estático para permitir que se use en toda la clase.

Example [Link] – FunctionHandler

using Amazon.EC2;
...
public class Function
{
private static AmazonEC2Client ec2Client;

static Function() {
[Link]();
ec2Client = new AmazonEC2Client();
}

224
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

public async Task<string> FunctionHandler(Dictionary<string, string> input,

ILambdaContext context)
{
// More AMI IDs: [Link]/amazon-linux-2/release-notes/
// us-east-2 HVM EBS-Backed 64-bit Amazon Linux 2
string ami = "ami-09d9edae5eb90d556";
string sg = "default";
InstanceType type = InstanceType.T3aNano;
string price = "0.003";
int count = 1;
var requestSpotInstances = await RequestSpotInstance(ami, sg, type, price,
count);
var spotRequestId =
[Link][0].SpotInstanceRequestId;

El método RequestSpotInstance crea una solicitud de instancia de spot.

Example [Link] – RequestSpotInstance

using Amazon;
using [Link];
using Amazon.EC2;
using [Link];
...
public async Task<RequestSpotInstancesResponse> RequestSpotInstance(
string amiId,
string securityGroupName,
InstanceType instanceType,
string spotPrice,
int instanceCount)
{
var request = new RequestSpotInstancesRequest();

var launchSpecification = new LaunchSpecification();

[Link] = amiId;
[Link] = instanceType;
[Link](securityGroupName);

[Link] = spotPrice;
[Link] = instanceCount;
[Link] = launchSpecification;

RequestSpotInstancesResponse response = await

[Link](request);

return response;
}
...

A continuación, debemos esperar hasta que la solicitud de spot alcance el estado Active antes
de continuar con el último paso. Para determinar el estado de la solicitud de spot, utilice el método
DescribeSpotInstanceRequests para obtener el estado del ID de solicitud de spot que deseamos
monitorizar.

public async Task<SpotInstanceRequest> GetSpotRequest(string spotRequestId)

{
var request = new DescribeSpotInstanceRequestsRequest();
[Link](spotRequestId);

var describeResponse = await [Link](request);

return [Link][0];

225
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

El paso final consiste en limpiar las instancias y solicitudes. Es importante tanto para cancelar cualquier
solicitud pendiente como para terminar cualquier instancia. Las instancias no terminarán con solo
cancelarse las solicitudes, lo que significa que se le seguirá cobrando por ellas. Si termina las instancias,
es posible que se cancelen las solicitudes de spot, pero hay algunos escenarios (por ejemplo, si usa
solicitudes persistentes), donde terminar las instancias no es suficiente para evitar que la solicitud vuelva
a atenderse. Por lo tanto, se recomienda tanto cancelar cualquier solicitud activa como terminar cualquier
instancia en ejecución.

Puede usar el método CancelSpotInstanceRequests para cancelar una solicitud de spot. En el siguiente
ejemplo se muestra cómo cancelar una solicitud de subasta.

public async Task CancelSpotRequest(string spotRequestId)

{
[Link]("Canceling request " + spotRequestId);
var cancelRequest = new CancelSpotInstanceRequestsRequest();
[Link](spotRequestId);

await [Link](cancelRequest);
}

Puede usar el método TerminateInstances para terminar una instancia.

public async Task TerminateSpotInstance(string instanceId)

{
[Link]("Terminating instance " + instanceId);
var terminateRequest = new TerminateInstancesRequest();
[Link] = new List<string>() { instanceId };
try
{
var terminateResponse = await [Link](terminateRequest);
}
catch (AmazonEC2Exception ex)
{
// Check the ErrorCode to see if the instance does not exist.
if ("[Link]" == [Link])
{
[Link]("Instance {0} does not exist.", instanceId);
}
else
{
// The exception was thrown for another reason, so re-throw the exception.
throw;
}
}
}

Ejecución del código localmente

Ejecute el código en su máquina local para crear una solicitud de instancia de spot. Una vez cumplida la
solicitud, el código elimina la solicitud y termina la instancia.

Para ejecutar el código de la aplicación

1. Vaya al directorio [Link].

$ cd test/[Link]

226
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

2. Utilice la CLI de .NET para ejecutar las pruebas de unidad del proyecto.

test/[Link]$ dotnet test

Starting test execution, please wait...
sir-x5tgs5ij
open
open
open
open
open
active
Canceling request sir-x5tgs5ij
Terminating instance i-0b3fdff0e12e0897e
Complete

Test Run Successful.

Total tests: 1
Passed: 1
Total time: 7.6060 Seconds

La prueba de unidad invoca el método FunctionHandler para crear una solicitud de instancia de spot,
supervisarla y limpiarla. Se implementa en el marco de pruebas [Link].

Implementación de la aplicación
Ejecute el código en Lambda como punto de partida para crear una aplicación sin servidor.

Para implementar y probar la aplicación

1. Establezca su región en us-east-2.

$ export AWS_DEFAULT_REGION=us-east-2

2. Cree un bucket para artefactos de implementación.

$ ./[Link]
make_bucket: lambda-artifacts-63d5cbbf18fa5ecc

3. Cree un paquete de implementación e implemente la aplicación.

$ ./[Link]
Amazon Lambda Tools for .NET Core applications (3.3.0)
Project Home: [Link] [Link]
aws/aws-lambda-dotnet

Executing publish command

...
Created publish archive ([Link])
Lambda project successfully packaged: [Link]
Uploading to ebd38e401cedd7d676d05d22b76f0209 1305107 / 1305107.0 (100.00%)
Successfully packaged artifacts and wrote output template to file [Link].
Execute the following command to deploy the packaged template
aws cloudformation deploy --template-file [Link] --stack-name <YOUR STACK NAME>

Waiting for changeset to be created..

Waiting for stack create/update to complete
Successfully created/updated stack - ec2-spot

4. Abra la página Applications (Aplicaciones) de la consola de Lambda.

227
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

5. En Resources (Recursos), elija function (función).

6. Elija Test (Prueba) y cree un evento de prueba a partir de la plantilla predeterminada.
7. Elija Test (Probar) de nuevo para invocar la función.

Ver los registros y la información de rastreo para ver el ID de solicitud de spot y la secuencia de llamadas a
Amazon EC2.

Para ver el mapa de servicio, abra la página Service map (Mapa de servicio) en la consola de X-Ray.

228
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

Elija un nodo en el mapa de servicio y, a continuación, elija View traces (Ver seguimientos) para ver una
lista de rastreos. Elija un rastreo de la lista para ver la línea de tiempo de las llamadas que efectuó la
función a Amazon EC2.

229
 AWS Lambda Guía para desarrolladores
Tutorial: Instancias de spot

Eliminación
El código proporcionado en este tutorial está diseñado para crear y eliminar solicitudes de instancias de
spot y para terminar las instancias que inician. Sin embargo, si se produce un error, es posible que las

230
 AWS Lambda Guía para desarrolladores
AWS IoT

solicitudes e instancias no se limpien automáticamente. Visualice las solicitudes e instancias puntuales en

la consola de Amazon EC2.

Para confirmar que los recursos de Amazon EC2 se limpian

1. Abra la página Spot Requests (Solicitudes de spot) en la consola de Amazon EC2.

2. Compruebe que el estado de las solicitudes sea Cancelled (Cancelado).
3. Seleccione el ID de instancia en la columna Capacity (Capacidad) para ver la instancia.
4. Compruebe que el estado de las instancias sea Terminated (Terminado) o Shutting down (Cierre).

Para limpiar la función de ejemplo y los recursos de soporte, elimine su pila de AWS CloudFormation y el
bucket de artefactos que creó.

$ ./[Link]
Delete deployment artifacts and bucket (lambda-artifacts-63d5cbbf18fa5ecc)?y
delete: s3://lambda-artifacts-63d5cbbf18fa5ecc/ebd38e401cedd7d676d05d22b76f0209
remove_bucket: lambda-artifacts-63d5cbbf18fa5ecc

El grupo de registro de la función no se elimina automáticamente. Puede eliminarlo en la consola

de CloudWatch Logs. Los rastreos en X-Ray caducan después de unas semanas y se eliminan
automáticamente.

Uso de AWS Lambda con AWS IoT

AWS IoT proporciona una comunicación segura entre dispositivos conectados a Internet (como sensores)
y la nube de AWS. Esto le permite recopilar, almacenar y analizar los datos de telemetría de varios
dispositivos.

Puede crear reglas de AWS IoT para que sus dispositivos interactúen con los servicios de AWS. El motor
de reglas de AWS IoT proporciona un lenguaje basado en SQL para seleccionar datos de cargas de
mensajes y enviar los datos a otros servicios como Amazon S3, Amazon DynamoDB y AWS Lambda.
Cuando quiera invocar otro servicio de AWS o un servicio de terceros, defina una regla para invocar una
función Lambda.

Cuando un mensaje de IoT entrante desencadena la regla, AWS IoT invoca su función Lambda de forma
asíncrona (p. 89) y pasa los datos del mensaje de IoT a la función.

El siguiente ejemplo muestra una lectura de humedad del sensor de un invernadero. Los valores row y
pos identifican la ubicación del sensor. Este evento de ejemplo se basa en el tipo de invernadero de los
Tutoriales de reglas de AWS IoT.

Example Ejemplo de evento de mensaje de AWS IoT

{
"row" : "10",
"pos" : "23",
"moisture" : "75"
}

En la invocación asincrónica, Lambda pone en cola el mensaje y, si la función devuelve un error, lo intenta
de nuevo (p. 107). Configure la función con un destino (p. 92) para conservar los eventos que la función no
puede procesar.

Debe conceder permiso para que el servicio AWS IoT invoque su función de Lambda. Utilice el comando
add-permission para añadir una instrucción de permiso a la política basada en recursos de la función.

231
 AWS Lambda Guía para desarrolladores
AWS IoT Events

$ aws lambda add-permission --function-name my-function \

--statement-id iot-events --action "lambda:InvokeFunction" principal
[Link]
{
"Statement": "{\"Sid\":\"iot-events\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":
\"arn:aws:lambda:us-west-2:123456789012:function:my-function\"}"
}

Para obtener más información acerca de cómo utilizar Lambda con AWS IoT, consulte Creación de una
regla de AWS Lambda.

Uso de AWS Lambda con AWS IoT Events

AWS IoT Events monitoriza las entradas desde varios sensores y aplicaciones de IoT para reconocer
patrones de evento. Luego realizar las acciones apropiadas cuando ocurren eventos. AWS IoT Events
recibe sus entradas como cargas JSON de muchas fuentes. AWS IoT Events admite eventos simples
(donde cada entrada desencadena un evento) y eventos complejos (donde se deben producir múltiples
entradas para desencadenar el evento).

Para usar AWS IoT Events, defina un modelo de detector, que es un modelo de máquina de estado de
su equipo o proceso. Además de los estados, se definen entradas y eventos para el modelo. También se
definen las acciones que se deben realizar cuando se produce un evento. Utilice una función Lambda para
una acción cuando desee invocar otro servicio de AWS (como Amazon Connect) o realizar acciones en
una aplicación externa (como la aplicación de planificación de recursos empresariales (ERP)).

Cuando se produce el evento, AWS IoT Events invoca su función de Lambda de forma asíncrona.
Proporciona información sobre el modelo del detector y el evento que desencadenó la acción. El siguiente
evento de mensaje de ejemplo se basa en las definiciones del ejemplo paso a paso sencillo de AWS IoT
Events.

Example Ejemplo de evento de mensaje de AWS IoT Events

{
"event: ":{
"eventName": "myChargedEvent",
"eventTime": 1567797571647,
"payload":{
"detector":{
"detectorModelName": "AWS_IoTEvents_Hello_World1567793458261",
"detectorModelVersion": "4",
"keyValue": "100009"
},
"eventTriggerDetails":{
"triggerType": "Message",
"inputName": "AWS_IoTEvents_HelloWorld_VoltageInput",
"messageId": "64c75a34-068b-4a1d-ae58-c16215dc4efd"
},
"actionExecutionId": "49f0f32f-1209-38a7-8a76-d6ca49dd0bc4",
"state":{
"variables": {},
"stateName": "Charged",
"timers": {}
}
}
}
}

232
 AWS Lambda Guía para desarrolladores
Kinesis

El evento que se pasa a la función de Lambda incluye los siguientes campos:

• eventName: el nombre de este evento en el modelo de detector.

• eventTime: la hora a la que se produjo el evento.
• detector: el nombre y la versión del modelo de detector.
• eventTriggerDetails: una descripción de la entrada que desencadenó el evento.
• actionExecutionId: el identificador de ejecución único de la acción.
• state: el estado del modelo de detector cuando se produjo el evento.
• stateName: el nombre del estado en el modelo de detector.
• timers: cualquier temporizador que se establezca en este estado.
• variables: cualquier valor de variable que se establece en este estado.

Debe conceder permiso para que el servicio AWS IoT Events invoque su función de Lambda. Utilice el
comando add-permission para añadir una instrucción de permiso a la política basada en recursos de la
función.

$ aws lambda add-permission --function-name my-function \

--statement-id iot-events --action "lambda:InvokeFunction" principal
[Link]
{
"Statement": "{\"Sid\":\"iot-events\",\"Effect\":\"Allow\",\"Principal\":{\"Service
\":\"[Link]\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":
\"arn:aws:lambda:us-west-2:123456789012:function:my-function\"}"
}

Para obtener más información sobre cómo utilizar Lambda con AWS IoT Events, consulte Uso de AWS IoT
Events con otros servicios.

Uso de AWS Lambda con Amazon Kinesis

Puede utilizar una función de AWS Lambda para procesar los registros de un flujo de datos de
Amazon Kinesis. Con Kinesis, puede recopilar datos de muchos orígenes y procesarlos con múltiples
consumidores. Lambda admite iteradores de flujo de datos estándar y consumidores de flujos HTTP/2.

Lambda lee registros del flujo de datos e invoca la función sincrónicamente (p. 88) con un evento que
contenga registros de flujo. Lambda lee registros en lotes e invoca la función para procesar registros desde
el lote.

Example Kinesis Evento de registro.

{
"Records": [
{
"kinesis": {
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data": "SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
"approximateArrivalTimestamp": 1545084650.987
},

233
 AWS Lambda Guía para desarrolladores
Kinesis

"eventSource": "aws:kinesis",
"eventVersion": "1.0",
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"eventName": "aws:kinesis:record",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role",
"awsRegion": "us-east-2",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream"
},
{
"kinesis": {
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692540925702759324208523137515618",
"data": "VGhpcyBpcyBvbmx5IGEgdGVzdC4=",
"approximateArrivalTimestamp": 1545084711.166
},
"eventSource": "aws:kinesis",
"eventVersion": "1.0",
"eventID":
"shardId-000000000006:49590338271490256608559692540925702759324208523137515618",
"eventName": "aws:kinesis:record",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role",
"awsRegion": "us-east-2",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream"
}
]
}

Si tiene varias aplicaciones que leen registros desde el mismo flujo, puede utilizar consumidores de flujos
de Kinesis en lugar de iteradores estándar. Los consumidores tienen rendimiento de lectura dedicado
para que no tengan que competir con otros consumidores de los mismos datos. Mediante el uso de los
consumidores, Kinesis inserta los registros en Lambda través de una conexión HTTP/2, lo que también
puede reducir la latencia entre la adición de un registro y la invocación de la función.
Note

La ventana de lotes, el control de errores y la configuración de simultaneidad no están disponibles

para los consumidores de flujos HTTP/2.

De forma predeterminada, Lambda llama a su función en cuanto los registros están disponibles en el flujo.
Si el lote que lee desde el flujo solo tiene un registro, Lambda solo envía un registro a la función. Para
evitar invocar a la función con un número de registros pequeño, puede indicar al origen del evento que
almacene en búfer registros durante hasta 5 minutos configurando una ventana de lote. Antes de invocar
a la función, Lambda sigue leyendo registros desde el flujo hasta que haya recopilado un lote completo o
hasta que caduca la ventana de lote.

Si la función devuelve un error, Lambda volverá a intentar ejecutar el lote hasta que el procesamiento
se realice correctamente o los datos caduquen. Para evitar particiones detenidas, puede configurar la
asignación del origen de eventos para que vuelva a intentarlo con un tamaño de lote menor, para que limite
el número de reintentos o para que se descarten los registros que sean muy antiguos. Si desea conservar
los eventos descartados, puede configurar la asignación del origen de eventos para que envíe información
sobre los lotes con errores a una cola de SQS o un tema de SNS.

También puede aumentar la simultaneidad procesando varios lotes de cada partición en paralelo. Lambda
puede procesar hasta 10 lotes en cada partición simultáneamente. Si aumenta el número de lotes
simultáneos en cada partición, Lambda seguirá garantizando que el procesamiento se realiza en orden en
el nivel de la clave de partición.

Secciones
• Configurar su flujo de datos y función. (p. 235)

234
 AWS Lambda Guía para desarrolladores
Configurar su flujo de datos y función.

• Permisos de rol de ejecución (p. 235)

• Configuración de una secuencia como un origen de eventos (p. 236)
• API de mapeo de origen de eventos (p. 237)
• Control de errores (p. 239)
• Métricas de Amazon CloudWatch (p. 240)
• Tutorial: uso de AWS Lambda con Amazon Kinesis (p. 240)
• Código de función de muestra (p. 243)
• Plantilla de AWS SAM para una aplicación de Kinesis (p. 247)

Configurar su flujo de datos y función.

Su función de Lambda es una aplicación consumidora para su flujo de datos. Procesa un lote de registros
a la vez desde cada partición. Puede mapear una función de Lambda a un flujo de datos (iterador
estándar) o a un consumidor de un flujo (distribución ramificada mejorada).

Para los iteradores estándar, Lambda sondea cada partición del flujo de Kinesis y busca registros una vez
por segundo. Cuando hay más registros disponibles, Lambda sigue procesando lotes hasta que la función
se pone al día con el flujo. El mapeo de origen de eventos comparte el rendimiento de lectura con otros
consumidores de la partición.

Para minimizar la latencia y maximizar el rendimiento de lectura, cree un consumidor de flujo de datos.
Los consumidores de flujos obtienen una conexión dedicada a cada partición que no afecta a las demás
aplicaciones que leen el flujo. El rendimiento dedicado puede ser útil si hay muchas aplicaciones que leen
los mismos datos, o si se está reprocesando un flujo con registros de gran tamaño.

Los consumidores de flujos utilizan HTTP/2 para reducir la latencia enviando los registros a Lambda a
través de una conexión de larga duración y mediante la compresión de los encabezados de las solicitudes.
Es posible crear un consumidor de flujos con la API RegisterStreamConsumer de Kinesis.

$ aws kinesis register-stream-consumer --consumer-name con1 \

--stream-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream
{
"Consumer": {
"ConsumerName": "con1",
"ConsumerARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream/
consumer/con1:1540591608",
"ConsumerStatus": "CREATING",
"ConsumerCreationTimestamp": 1540591608.0
}
}

Para incrementar la velocidad con la que la función procesa los registros, añada particiones al flujo de
datos. Lambda procesa los registros de cada partición por orden. Deja de procesar registros adicionales
en una partición si la función devuelve un error. Al haber más particiones, se procesan más lotes
simultáneamente, lo que reduce el impacto de los errores de simultaneidad.

Si la función no puede aumentar para gestionar el número total de lotes simultáneos, solicite un aumento
de límite (p. 30) o reserve la simultaneidad (p. 59) para la función.

Permisos de rol de ejecución

Lambda necesita los siguientes permisos para administrar los recursos relacionados con el flujo de datos
de Kinesis. Añádalos a rol de ejecución (p. 32) de su función.

• kinesis:DescribeStream

235
 AWS Lambda Guía para desarrolladores
Configuración de una secuencia como un origen de eventos

• kinesis:DescribeStreamSummary
• kinesis:GetRecords
• kinesis:GetShardIterator
• kinesis:ListShards
• kinesis:ListStreams
• kinesis:SubscribeToShard

La política administrada AWSLambdaKinesisExecutionRole contiene los permisos siguientes: Para

obtener más información, consulte Rol de ejecución de AWS Lambda (p. 32).

Para enviar registros de un lote con errores a una cola o un tema, la función necesita permisos adicionales.
Cada servicio de destino requiere un permiso diferente, como se indica a continuación:

• Amazon SQS: sqs:SendMessage

• Amazon SNS: sns:Publish

Configuración de una secuencia como un origen de

eventos
Cree un mapeo de origen de eventos para indicar a Lambda que envíe registros de un flujo de datos a
una función de Lambda. Puede crear varios mapeos de orígenes de eventos para procesar los mismos
datos con distintas funciones de Lambda o para procesar elementos de varios flujos de datos con una sola
función.

Para configurar la función para leer de Kinesis en la consola de Lambda, cree un desencadenador de
Kinesis.

Para crear un disparador

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add trigger (Añadir disparador).
4. Elija un tipo de disparador.
5. Configure las opciones necesarias y, a continuación, elija Add (Añadir).

Lambda admite las siguientes opciones para los orígenes de eventos de Kinesis.

Opciones de origen de eventos

• Kinesis stream (Flujo de Kinesis): el flujo de – Kinesis cuyos registros se leen.

• Consumer (Consumidor)– (opcional): utilizar un consumidor de flujos para leer los datos del flujo a través
de una conexión dedicada.
• Batch size (Tamaño del lote): número de registros que hay que enviar a la función en cada lote, hasta 10
000. Lambda pasa todos los registros del lote a la función en una sola llamada, siempre que el tamaño
total de los eventos no supere el límite de carga (p. 30) para la invocación asíncrona (6 MB).
• Batch window (Ventana de lote): especifique la cantidad de tiempo máxima para recopilar registros antes
de invocar la función, en segundos.
• Starting position (Posición inicial): procesar solo los registros nuevos, todos los registros existentes o los
registros creados después de cierta fecha.
• Latest (Más recientes): procesar los registros nuevos que se añaden al flujo principal.
• Trim horizon (Horizonte de supresión): procesar todos los registros del flujo.

236
 AWS Lambda Guía para desarrolladores
API de mapeo de origen de eventos

• At timestamp (En marca temporal): procesar los registros comenzando a partir de un momento
determinado.

Tras procesar cualquier registro existente, la función es alcanzada y continúa procesando registros
nuevos.
• On-failure destination (Destino en caso de error): cola de SQS o tema de SNS de los registros que no
pueden procesarse. Cuando Lambda descarta un lote de registros porque es demasiado antiguo o se
han agotado todos los reintentos, envía información sobre el lote a la cola o al tema.
• Retry attempts (Número de reintentos): número máximo de reintentos que Lambda realiza cuando la
función devuelve un error. No se aplica a los errores ni las limitaciones de los servicios en los que el lote
no alcanza la función.
• Maximum age of record (Antigüedad máxima del registro): antigüedad máxima de un registro que
Lambda envía a la función.
• Split batch on error (Dividir lote en caso de error): cuando la función devuelve un error, el lote se divide
en dos antes de intentarlo de nuevo.
• Process multiple batches from the same shard concurrently (Lotes simultáneos por partición): procesa
simultáneamente varios lotes de la misma partición.
• Enabled (Habilitado): desactivar el origen de eventos para dejar de procesar registros. Lambda toma
nota del último registro procesado y sigue procesando desde ese punto cuando se habilita de nuevo.

Para administrar la configuración de origen de evento más tarde, elija el desencadenador en el diseñador.

API de mapeo de origen de eventos

Para administrar las asignaciones de orígenes de eventos con la AWS CLI o el SDK de AWS, utilice las
siguientes acciones de la API:

• CreateEventSourceMapping (p. 460)

• ListEventSourceMappings (p. 537)
• GetEventSourceMapping (p. 496)
• UpdateEventSourceMapping (p. 592)
• DeleteEventSourceMapping (p. 477)

Para crear el mapeo de orígenes de eventos con la AWS CLI, use el comando create-event-source-
mapping. En el siguiente ejemplo, se utiliza la AWS CLI para asignar una función denominada my-
function a un flujo de datos de Kinesis. El flujo de datos se especifica mediante un nombre de recurso
de Amazon (ARN) con un tamaño de lote de 500, comenzando desde una marca temporal en tiempo Unix.

$ aws lambda create-event-source-mapping --function-name my-function \

--batch-size 500 --starting-position AT_TIMESTAMP --starting-position-timestamp 1541139109
\
--event-source-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream
{
"UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284",
"BatchSize": 500,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1541139209.351,
"LastProcessingResult": "No records processed",
"State": "Creating",
"StateTransitionReason": "User action",
"DestinationConfig": {},
"MaximumRecordAgeInSeconds": 604800,

237
 AWS Lambda Guía para desarrolladores
API de mapeo de origen de eventos

"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 10000
}

Para utilizar un consumidor, especifique el ARN del consumidor en lugar del ARN del flujo.

Configure otras opciones para personalizar el modo en que se procesan los lotes y especificar cuándo
deben descargarse los registros que no se pueden procesar. En el siguiente ejemplo, se actualiza la
asignación de un origen de eventos para enviar un registro de error a una cola de SQS después de dos
reintentos o si los registros tienen más de una hora de antigüedad.

$ aws lambda update-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \

--maximum-retry-attempts 2 --maximum-record-age-in-seconds 3600
--destination-config '{"OnFailure": {"Destination": "arn:aws:sqs:us-
east-2:123456789012:dlq"}}'
{
"UUID": "f89f8514-cdd9-4602-9e1f-01a5b77d449b",
"BatchSize": 100,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1573243620.0,
"LastProcessingResult": "PROBLEM: Function call failed",
"State": "Updating",
"StateTransitionReason": "User action",
"DestinationConfig": {},
"MaximumRecordAgeInSeconds": 604800,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 10000
}

La configuración actualizada se aplica de forma asincrónica y no se refleja en la salida hasta que se

completa el proceso. Utilice el comando get-event-source-mapping para ver el estado actual.

$ aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b

{
"UUID": "f89f8514-cdd9-4602-9e1f-01a5b77d449b",
"BatchSize": 100,
"MaximumBatchingWindowInSeconds": 0,
"ParallelizationFactor": 1,
"EventSourceArn": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1573244760.0,
"LastProcessingResult": "PROBLEM: Function call failed",
"State": "Enabled",
"StateTransitionReason": "User action",
"DestinationConfig": {
"OnFailure": {
"Destination": "arn:aws:sqs:us-east-2:123456789012:dlq"
}
},
"MaximumRecordAgeInSeconds": 3600,
"BisectBatchOnFunctionError": false,
"MaximumRetryAttempts": 2
}

Para procesar varios lotes simultáneamente, utilice la opción --parallelization-factor.

$ aws lambda update-event-source-mapping --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 \

--parallelization-factor 5

238
 AWS Lambda Guía para desarrolladores
Control de errores

Control de errores
La asignación del origen de eventos que lee los registros de la secuencia de Kinesis invoca la función de
forma sincrónica y reintenta la operación si se producen errores. Si la función se ve limitada o el servicio de
Lambda devuelve un error sin invocar la función, Lambda vuelve a intentarlo hasta que el registro expira o
supera la antigüedad máxima establecida en la asignación del origen de eventos.

Si la función recibe los registros pero devuelve un error, Lambda lo vuelve a intentar hasta que vencen los
registros del lote, se supera la antigüedad máxima o se alcanza el límite de reintentos especificado. En el
caso de los errores de funciones, también puede configurar la asignación del origen de eventos para que
divida en dos los lotes que presentan errores. Al intentarlo con lotes más pequeños, se aíslan los registros
erróneos y se solucionan problemas relacionadas con el tiempo de espera. Los lotes divididos no se tienen
en cuenta para calcular el límite de reintentos.

Si las medidas de administración de errores no funcionan, Lambda descarta los registros y sigue
procesando los lotes de la secuencia. Con la configuración predeterminada, esto significa que un registro
erróneo puede bloquear el procesamiento de la partición afectada durante un máximo de one week.
Para evitar esto, configure la asignación del origen de eventos de la función con un número razonable de
reintentos y una antigüedad de registro máxima que se ajuste a su caso de uso.

Para mantener un registro de los lotes descartados, configure un destino de evento fallido. Lambda enviará
un documento a la cola o al tema de destino con información sobre el lote.

Para configurar un destino para registros de eventos con errores

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add destination (Añadir destino).
4. En Source (Origen), elija Stream invocation (Invocación por secuencias).
5. En Stream (Secuencia), elija una secuencia que esté asignada a la función.
6. En Destination type (Tipo de destino), elija el tipo de recurso que recibe el registro de invocación.
7. En Destination (Destino), elija un recurso.
8. Elija Save (Guardar).

El siguiente ejemplo muestra un registro de invocación para un flujo de Kinesis.

Example Registro de invocación

{
"requestContext": {
"requestId": "c9b8fa9f-5a7f-xmpl-af9c-0c604cde93a5",
"functionArn": "arn:aws:lambda:us-east-2:123456789012:function:myfunction",
"condition": "RetryAttemptsExhausted",
"approximateInvokeCount": 1
},
"responseContext": {
"statusCode": 200,
"executedVersion": "$LATEST",
"functionError": "Unhandled"
},
"version": "1.0",
"timestamp": "2019-11-14T00:38:06.021Z",
"KinesisBatchInfo": {
"shardId": "shardId-000000000001",
"startSequenceNumber": "49601189658422359378836298521827638475320189012309704722",
"endSequenceNumber": "49601189658422359378836298522902373528957594348623495186",
"approximateArrivalOfFirstRecord": "2019-11-14T00:38:04.835Z",
"approximateArrivalOfLastRecord": "2019-11-14T00:38:05.580Z",

239
 AWS Lambda Guía para desarrolladores
Métricas de Amazon CloudWatch

"batchSize": 500,
"streamArn": "arn:aws:kinesis:us-east-2:123456789012:stream/mystream"
}
}

Puede utilizar esta información para recuperar los registros afectados de la secuencia y solucionar los
problemas. Los registros reales no están incluidos, por lo que debe procesar este registro y recuperarlos
de la secuencia antes de que venzan y se pierdan.

Métricas de Amazon CloudWatch

Lambda emite la métrica IteratorAge cuando la función termina de procesar un lote de registros.
La métrica indica la antigüedad del último registro del lote cuando acabo el proceso. Si la función está
procesando nuevos eventos, puede utilizar la antigüedad del iterador para estimar la latencia entre el
momento en que se añade un registro y el momento en que la función lo procesa.

Una tendencia ascendente en la antigüedad del iterador puede indicar problemas con la función. Para
obtener más información, consulte Trabajar con métricas de función de AWS Lambda (p. 400).

Tutorial: uso de AWS Lambda con Amazon Kinesis

En este tutorial, se crea una función de Lambda para consumir eventos de un flujo de Kinesis. En el
diagrama siguiente se ilustra el flujo de la aplicación:

1. Una aplicación personalizada escribe los registros en el flujo.

2. AWS Lambda sondea el flujo y, cuando detecta registros nuevos en él, llama a la función de Lambda.
3. AWS Lambda ejecuta la función de Lambda asumiendo el rol de ejecución que se especificó en el
momento de crear la función de Lambda.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

240
 AWS Lambda Guía para desarrolladores
Tutorial

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – AWS Lambda.

• Permissions (Permisos): AWSLambdaSQSQueueExecutionRole.
• Role name (Nombre de rol): lambda-kinesis-role.

La política AWSLambdaKinesisExecutionRole tiene permisos que la función necesita para leer elementos
de Kinesis y escribir registros a CloudWatch Logs.

Creación de la función
A continuación se muestra código de ejemplo que recibe un evento de Kinesis como entrada y procesa
los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 243).

Example [Link]

[Link]('Loading function');

[Link] = function(event, context) {

//[Link]([Link](event, null, 2));
[Link](function(record) {
// Kinesis data is base64 encoded so decode here
var payload = [Link]([Link], 'base64').toString('ascii');
[Link]('Decoded payload:', payload);
});
};

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name ProcessKinesisRecords \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \

241
 AWS Lambda Guía para desarrolladores
Tutorial

--role arn:aws:iam::123456789012:role/lambda-kinesis-role

Pruebe la función Lambda.

Invoque la función de Lambda manualmente mediante el comando invoke de la CLI de AWS Lambda y
un evento de Kinesis de muestra.

Para probar la función de Lambda

1. Copie el siguiente JSON en un archivo y guárdelo como [Link].

{
"Records": [
{
"kinesis": {
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data": "SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
"approximateArrivalTimestamp": 1545084650.987
},
"eventSource": "aws:kinesis",
"eventVersion": "1.0",
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"eventName": "aws:kinesis:record",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-kinesis-role",
"awsRegion": "us-east-2",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-
stream"
}
]
}

2. Utilice el comando invoke para enviar el evento a la función.

$ aws lambda invoke --function-name ProcessKinesisRecords --payload [Link]

[Link]

La respuesta se guardará en el archivo [Link].

Crear un flujo de Kinesis

Utilice el comando create-stream para crear un flujo.

$ aws kinesis create-stream --stream-name lambda-stream --shard-count 1

Ejecute el siguiente comando describe-stream para obtener el ARN del flujo.

$ aws kinesis describe-stream --stream-name lambda-stream

{
"StreamDescription": {
"Shards": [
{
"ShardId": "shardId-000000000000",
"HashKeyRange": {
"StartingHashKey": "0",

242
 AWS Lambda Guía para desarrolladores
Código de muestra

"EndingHashKey": "340282366920746074317682119384634633455"
},
"SequenceNumberRange": {
"StartingSequenceNumber":
"49591073947768692513481539594623130411957558361251844610"
}
}
],
"StreamARN": "arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream",
"StreamName": "lambda-stream",
"StreamStatus": "ACTIVE",
"RetentionPeriodHours": 24,
"EnhancedMonitoring": [
{
"ShardLevelMetrics": []
}
],
"EncryptionType": "NONE",
"KeyId": null,
"StreamCreationTimestamp": 1544828156.0
}
}

Utilice el ARN del flujo en el siguiente paso para asociar el flujo a la función de Lambda.

Adición de un origen de evento en AWS Lambda

Ejecute el comando siguiente AWS CLI add-event-source.

$ aws lambda create-event-source-mapping --function-name ProcessKinesisRecords \

--event-source arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream \
--batch-size 100 --starting-position LATEST

Tenga en cuenta el ID de mapeo para un uso posterior. Para obtener una lista de mapeos de orígenes de
eventos, ejecute el comando list-event-source-mappings.

$ aws lambda list-event-source-mappings --function-name ProcessKinesisRecords \

--event-source arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream

En la respuesta, puede comprobar que el valor de estado es enabled. Los mapeos de orígenes de
eventos se pueden deshabilitar para poner en pausa temporalmente el sondeo sin perder de registros.

Prueba de la configuración
Para probar el mapeo de origen de eventos, añada los registros de eventos a su flujo de Kinesis. El valor
de --data es una cadena que la CLI codifica en base64 antes de enviarlo a Kinesis. Puede ejecutar el
mismo comando más de una vez para añadir varios registros al flujo.

$ aws kinesis put-record --stream-name lambda-stream --partition-key 1 \

--data "Hello, this is a test."

Lambda utiliza el rol de ejecución para leer los registros desde el flujo. A continuación, se invoca la función
de Lambda y se pasan lotes de registros. La función descodifica los datos de cada registro y los registra,
enviando la salida a CloudWatch Logs. Puede ver los registros en la consola deCloudWatch.

Código de función de muestra

Para procesar eventos desde Amazon Kinesis, itere a través de los registros incluidos en el objeto de
evento y decodifique los datos codificados en Base64 incluidos en cada uno.

243
 AWS Lambda Guía para desarrolladores
Código de muestra

Note
El código de esta página no admite registros agregados. Puede deshabilitar la agregación en
la configuración de Kinesis Producer Library o utilice la biblioteca de agregación de registros de
Kinesis para desagregar registros.

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• [Link] 8 (p. 244)
• Java 11 (p. 244)
• C# (p. 245)
• Python 3 (p. 246)
• Go (p. 246)

[Link] 8
A continuación se muestra código de ejemplo que recibe un evento de Kinesis como entrada y procesa
los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.

Example [Link]

[Link]('Loading function');

[Link] = function(event, context) {

//[Link]([Link](event, null, 2));
[Link](function(record) {
// Kinesis data is base64 encoded so decode here
var payload = [Link]([Link], 'base64').toString('ascii');
[Link]('Decoded payload:', payload);
});
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

Java 11
A continuación, se muestra código de ejemplo de Java que recibe datos de registros de eventos de Kinesis
como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.

En el código, recordHandler es el controlador. Este controlador utiliza la clase KinesisEvent

predefinida, que se define en la biblioteca aws-lambda-java-events.

Example [Link]

package example;

import [Link];
import [Link];
import [Link];
import [Link];

public class ProcessKinesisRecords implements RequestHandler<KinesisEvent, Void>{

@Override
public Void handleRequest(KinesisEvent event, Context context)

244
 AWS Lambda Guía para desarrolladores
Código de muestra

{
for(KinesisEventRecord rec : [Link]()) {
[Link](new String([Link]().getData().array()));
}
return null;
}
}

Si el controlador vuelve normalmente sin excepciones, Lambda considera que el lote de registros de
entrada se ha procesado correctamente y empieza a leer nuevos registros en el flujo. Si el controlador
genera una excepción, Lambda considera que el lote de registros de entrada no se ha procesado e invoca
de nuevo la función con el mismo lote de registros.

Dependencias.

• aws-lambda-java-core
• aws-lambda-java-events
• aws-java-sdk

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

C#
A continuación, se muestra código de ejemplo de C# que recibe datos de registros de eventos de Kinesis
como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.

En el código, HandleKinesisRecord es el controlador. Este controlador utiliza la clase KinesisEvent

predefinida, que se define en la biblioteca [Link].

Example [Link]

using System;
using [Link];
using [Link];

using [Link];
using [Link];

namespace KinesisStreams
{
public class KinesisSample
{
[LambdaSerializer(typeof(JsonSerializer))]
public void HandleKinesisRecord(KinesisEvent kinesisEvent)
{
[Link]($"Beginning to process {[Link]}
records...");

foreach (var record in [Link])

{
[Link]($"Event ID: {[Link]}");
[Link]($"Event Name: {[Link]}");

string recordData = GetRecordContents([Link]);

[Link]($"Record Data:");
[Link](recordData);
}
[Link]("Stream processing complete.");

245
 AWS Lambda Guía para desarrolladores
Código de muestra

private string GetRecordContents([Link] streamRecord)

{
using (var reader = new StreamReader([Link], [Link]))
{
return [Link]();
}
}
}
}

Reemplace [Link] en un proyecto .NET Core con el ejemplo anterior. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en C# (p. 372).

Python 3
A continuación se muestra código de ejemplo de Python que recibe datos de registros de eventos de
Kinesis como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los
eventos de entrada en CloudWatch Logs.

Example [Link]

from __future__ import print_function

#import json
import base64
def lambda_handler(event, context):
for record in event['Records']:
#Kinesis data is base64 encoded so decode here
payload=base64.b64decode(record["kinesis"]["data"])
print("Decoded payload: " + str(payload))

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Go
A continuación se muestra código de ejemplo de Go que recibe datos de registros de eventos de Kinesis
como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.

Example [Link]

import (
"strings"
"[Link]/aws/aws-lambda-go/events"
)

func handler(ctx [Link], kinesisEvent [Link]) {

for _, record := range [Link] {
kinesisRecord := [Link]
dataBytes := [Link]
dataText := string(dataBytes)

[Link]("%s Data = %s \n", [Link], dataText)

}
}

Compile el ejecutable con go build y cree un paquete de implementación. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en Go (p. 359).

246
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

Plantilla de AWS SAM para una aplicación de Kinesis

Puede construir esta aplicación utilizando AWS SAM. Para obtener más información sobre la creación
de plantillas AWS SAM, diríjase a AWS SAM Aspectos básicos sobre plantillas en la Guía para
desarrolladores deModelo de aplicación sin servidor de AWS.

A continuación, hay una plantilla AWS SAM de muestra para la aplicación de Lambda del
tutorial (p. 240). La función y controlador de la plantilla corresponden al código de [Link]. Si utiliza un
código de muestra diferente, actualice los valores en consecuencia.

Example [Link]: flujo de Kinesis

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
LambdaFunction:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
Timeout: 10
Tracing: Active
Events:
Stream:
Type: Kinesis
Properties:
Stream: !GetAtt [Link]
BatchSize: 100
StartingPosition: LATEST
stream:
Type: AWS::Kinesis::Stream
Properties:
ShardCount: 1
Outputs:
FunctionName:
Description: "Function name"
Value: !Ref LambdaFunction
StreamARN:
Description: "Stream ARN"
Value: !GetAtt [Link]

La plantilla crea una función de Lambda, un flujo de Kinesis y un mapeo de origen de eventos. El mapeo
de origen de eventos lee del flujo e invoca la función.

Para utilizar un consumidor de flujos HTTP/2 (p. 235), cree el consumidor en la plantilla y configure el
mapeo de origen de eventos para que lea del consumidor en lugar de leer del flujo.

Example [Link]: consumidor de flujos de Kinesis

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: A function that processes data from a Kinesis stream.
Resources:
function:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
Timeout: 10
Tracing: Active
Events:
Stream:

247
 AWS Lambda Guía para desarrolladores
Kinesis Data Firehose

Type: Kinesis
Properties:
Stream: !GetAtt [Link]
StartingPosition: LATEST
BatchSize: 100
stream:
Type: "AWS::Kinesis::Stream"
Properties:
ShardCount: 1
streamConsumer:
Type: "AWS::Kinesis::StreamConsumer"
Properties:
StreamARN: !GetAtt [Link]
ConsumerName: "TestConsumer"
Outputs:
FunctionName:
Description: "Function name"
Value: !Ref function
StreamARN:
Description: "Stream ARN"
Value: !GetAtt [Link]
ConsumerARN:
Description: "Stream consumer ARN"
Value: !GetAtt [Link]

Para obtener más información sobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

Uso de AWS Lambda con Amazon Kinesis Data

Firehose
Amazon Kinesis Data Firehose captura, transforma y carga datos de streaming en servicios posteriores
como Kinesis Data Analytics o Amazon S3. Es posible escribir funciones de Lambda para realizar un
procesamiento adicional personalizado de los datos antes de enviarlos a los servicios posteriores.

Example Evento de mensaje de Amazon Kinesis Data Firehose

{
"invocationId": "invoked123",
"deliveryStreamArn": "aws:lambda:events",
"region": "us-west-2",
"records": [
{
"data": "SGVsbG8gV29ybGQ=",
"recordId": "record1",
"approximateArrivalTimestamp": 1510772160000,
"kinesisRecordMetadata": {
"shardId": "shardId-000000000000",
"partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c317a",
"approximateArrivalTimestamp": "2012-04-23T18:25:43.511Z",
"sequenceNumber": "49546986683135544286507457936321625675700192471156785154",
"subsequenceNumber": ""
}
},
{
"data": "SGVsbG8gV29ybGQ=",
"recordId": "record2",
"approximateArrivalTimestamp": 151077216000,
"kinesisRecordMetadata": {

248
 AWS Lambda Guía para desarrolladores
Amazon Lex

"shardId": "shardId-000000000001",
"partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c318a",
"approximateArrivalTimestamp": "2012-04-23T19:25:43.511Z",
"sequenceNumber": "49546986683135544286507457936321625675700192471156785155",
"subsequenceNumber": ""
}
}
]
}

Para obtener más información, consulte Transformación de datos de Amazon Kinesis Data Firehose en la
Guía para desarrolladores de Kinesis Data Firehose.

Uso de AWS Lambda con Amazon Lex

Amazon Lex es un servicio de AWS para crear interfaces de conversación en las aplicaciones con voz
y texto. Amazon Lex ofrece integración integrada con AWS Lambda, lo que permite crear funciones de
Lambda para utilizarlas como enlace de código con el bot de Amazon Lex. En la configuración de la
intención, puede identificar la función de Lambda para realizar la inicialización/validación, cumplimiento o
ambos.

Example Evento de mensaje de Amazon Lex

{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "ABCD1234",
"sessionAttributes": {
"key1": "value1",
"key2": "value2",
},
"bot": {
"name": "my-bot",
"alias": "prod",
"version": "1"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "my-intent",
"slots": {
"slot-name": "value",
"slot-name": "value",
"slot-name": "value"
},
"confirmationStatus": "Confirmed"
}
}

Para obtener más información, consulte Uso de funciones de Lambda. Para ver un ejemplo de caso de
uso, consulte Ejercicio 1: creación de un bot de Amazon Lex mediante un proyecto.

Uso de AWS Lambda con Amazon RDS

Puede utilizar AWS Lambda para procesar las notificaciones de eventos desde una base de datos de
Amazon Relational Database Service (Amazon RDS). Amazon RDS envía notificaciones a un tema de
Amazon Simple Notification Service (Amazon SNS), que puede configurar para invocar una función de
Lambda. Amazon SNS envuelve el mensaje desde Amazon RDS en su propio documento de evento y lo
envía a la función.

249
 AWS Lambda Guía para desarrolladores
Tutorial: Amazon RDS

Example Mensaje de Amazon RDS en un evento de Amazon SNS

{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:rds-lambda:21be56ed-
a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"SigningCertUrl": "[Link]
[Link]",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "{\"Event Source\":\"db-instance\",\"Event Time\":\"2019-01-02
12:45:06.000\",\"Identifier Link\":\"[Link]
west-1#dbinstance:id=dbinstanceid\",\"Source ID\":\"dbinstanceid\",\"Event ID\":\"http://
[Link]/AmazonRDS/latest/UserGuide/USER_Events.html#RDS-EVENT-0002\",
\"Event Message\":\"Finished DB Instance backup\"}",
"MessageAttributes": {},
"Type": "Notification",
"UnsubscribeUrl": "[Link]
Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-
lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "RDS Notification Message"
}
}
]
}

Para obtener instrucciones sobre cómo configurar una base de datos de Amazon RDS para enviar
notificaciones, consulte Uso de las notificaciones de eventos de Amazon RDS en la guía del usuario de
Amazon Relational Database Service.

Para obtener más información sobre cómo utilizar Amazon SNS como disparador, consulte Uso de AWS
Lambda con Amazon SNS (p. 271).

Temas
• Tutorial: Configuración de una función de Lambda para obtener acceso a Amazon RDS en una
Amazon VPC (p. 250)

Tutorial: Configuración de una función de Lambda

para obtener acceso a Amazon RDS en una Amazon
VPC
En este tutorial, aprenderá a hacer lo siguiente:

• Lanzar una instancia del motor de base de datos MySQL de Amazon RDS en la Amazon VPC
predeterminada. En la instancia de MySQL, debe crear una base de datos (ExampleDB) con una tabla
de muestra (Employee). Para obtener más información acerca de Amazon RDS, consulte Amazon RDS.
• Crear una función de Lambda para obtener acceso a la base de datos ExampleDB, crear una tabla
(Employee), añadir algunos registros y recuperar los registros de la tabla.
• Invocar la función de Lambda y verificar los resultados de la consulta. De este modo, se comprueba que
la función de Lambda ha podido tener acceso a la instancia de MySQL de RDS en la VPC.

250
 AWS Lambda Guía para desarrolladores
Tutorial: Amazon RDS

Para obtener más información sobre el uso de Lambda con Amazon VPC, consulte Configuración de una
función Lambda para obtener acceso a los recursos en una VPC (p. 78).

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza): Lambda.

• Permissions (Permisos) – AWSLambdaVPCAccessExecutionRole.
• Role name (Nombre de rol): lambda-vpc-role.

El AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para administrar las

conexiones de red a una VPC.

Crear una instancia de base de datos Amazon RDS.

En este tutorial, la función de Lambda del ejemplo crea una tabla (Employee), introduce algunos registros
y, a continuación, recupera los registros. La tabla creada por la función de Lambda tiene el siguiente
esquema:

Employee(EmpID, Name)

Donde EmpID es la clave principal. Ahora, debe añadir algunos registros a esta tabla.

En primer lugar, lance una instancia de MySQL de RDS en la VPC predeterminada con la base de datos
ExampleDB. Si ya tiene una instancia de MySQL de RDS ejecutándose en la VPC predeterminada, omita
este paso.

Puede lanzar una instancia de MySQL de RDS utilizando uno de los siguientes métodos:

251
 AWS Lambda Guía para desarrolladores
Tutorial: Amazon RDS

• Siga las instrucciones de Crear una instancia de base de datos MySQL y conectarse a una base de
datos en una instancia de base de datos MySQL en la Guía del usuario de Amazon RDS.
• Use el siguiente comando: AWS CLI

$ aws rds create-db-instance --db-name ExampleDB --engine MySQL \

--db-instance-identifier MySQLForLambdaTest --backup-retention-period 3 \
--db-instance-class [Link] --allocated-storage 5 --no-publicly-accessible \
--master-username username --master-user-password password

Anote el nombre de la base de datos, el nombre de usuario y la contraseña. Necesitará la dirección del
cliente (punto de enlace) de la base de datos que puede obtener en la consola de RDS. Puede que tenga
que esperar hasta que el estado de la instancia esté disponible y el valor del punto de enlace aparezca en
la consola.

Cree un paquete de implementación.

En el siguiente ejemplo de código de Python se ejecuta una consulta SELECT en la tabla Employee de
la instancia de RDS de MySQL que ha creado en la VPC. El código crea una tabla en la base de datos
ExampleDB, añade registros de muestra y recupera los registros.

Example [Link]

import sys
import logging
import rds_config
import pymysql
#rds settings
rds_host = "rds-instance-endpoint"
name = rds_config.db_username
password = rds_config.db_password
db_name = rds_config.db_name

logger = [Link]()
[Link]([Link])

try:
conn = [Link](rds_host, user=name, passwd=password, db=db_name,
connect_timeout=5)
except [Link] as e:
[Link]("ERROR: Unexpected error: Could not connect to MySQL instance.")
[Link](e)
[Link]()

[Link]("SUCCESS: Connection to RDS MySQL instance succeeded")

def handler(event, context):
"""
This function fetches content from MySQL RDS instance
"""

item_count = 0

with [Link]() as cur:

[Link]("create table Employee ( EmpID int NOT NULL, Name varchar(255) NOT
NULL, PRIMARY KEY (EmpID))")
[Link]('insert into Employee (EmpID, Name) values(1, "Joe")')
[Link]('insert into Employee (EmpID, Name) values(2, "Bob")')
[Link]('insert into Employee (EmpID, Name) values(3, "Mary")')
[Link]()
[Link]("select * from Employee")
for row in cur:
item_count += 1

252
 AWS Lambda Guía para desarrolladores
Tutorial: Amazon RDS

[Link](row)
#print(row)
[Link]()

return "Added %d items from RDS MySQL table" %(item_count)

Ejecutar [Link]() fuera del controlador permite que la función reutilice la conexión a la base
de datos para un rendimiento mejor.

Un segundo archivo contiene información de conexión para la función.

Example rds [Link]

#config file containing credentials for RDS MySQL instance

db_username = "username"
db_password = "password"
db_name = "ExampleDB"

Dependencias.

• pymysql: el código de la función de Lambda utiliza esta biblioteca para obtener acceso a la instancia de
MySQL (consulte PyMySQL).

Instale dependencias con Pip y cree un paquete de implementación. Para obtener instrucciones, consulte
Paquete de implementación de AWS Lambda en Python (p. 304).

Creación de la función Lambda

Cree la función de Lambda con el comando create-function. Puede encontrar los ID de la subred y el
ID de grupo de seguridad de su VPC predeterminada en la consola de Amazon VPC.

$ aws lambda create-function --function-name CreateTableAddRecordsAndRead --runtime

python3.8 \
--zip-file fileb://[Link] --handler [Link] \
--role arn:aws:iam::123456789012:role/lambda-vpc-role \
--vpc-config SubnetIds=subnet-0532bb6758ce7c71f,subnet-
d6b7fda068036e11f,SecurityGroupIds=sg-0897d5f549934c2fb

Prueba de la función de Lambda

En este paso, invocará la función de Lambda manualmente utilizando el comando invoke. Cuando se
ejecuta la función de Lambda, realiza la consulta SELECT en la tabla Employee de la instancia de MySQL
de RDS e imprime los resultados (estos resultados también van a CloudWatch Logs).

1. Invoque la función de Lambda con el comando invoke.

$ aws lambda invoke --function-name CreateTableAddRecordsAndRead [Link]

2. Compruebe que la función de Lambda se ha ejecutado correctamente del modo siguiente:

• Revise el archivo [Link].

• Revise los resultados en la consola de AWS Lambda.
• Verifique los resultados en CloudWatch Logs.

Ahora que ha creado una función de Lambda que tiene accede a una base de datos en la VPC,
puede hacer que la función se invoque en respuesta a eventos. Para obtener información acerca de

253
 AWS Lambda Guía para desarrolladores
Eventos de Amazon S3

la configuración de orígenes de eventos y ver ejemplos, consulte Uso de AWS Lambda con otros
servicios (p. 153).

Uso de AWS Lambda con eventos de Amazon S3

Puede utilizar Lambda para procesar notificaciones de eventos desde Amazon Simple Storage Service.
Amazon S3 puede enviar un evento a una función Lambda cuando se crea o elimina un objeto. Puede
configurar las opciones de notificación en un bucket y conceder a Amazon S3 permiso para invocar una
función en la política de permisos basada en recursos de la función.
Warning

Si la función de Lambda utiliza el mismo bucket que la activa, podría provocar la ejecución de la
función en un bucle. Por ejemplo, si el bucket activa una función cada vez que se carga un objeto
y la función carga un objeto en el bucket, la función se activa indirectamente a sí misma. Para
evitarlo, utilice dos buckets o configure el desencadenador para que solo se aplique a un prefijo
que se utiliza para los objetos entrantes.

Amazon S3 invoca la función de forma asíncrona (p. 89) con un evento que contiene detalles sobre el
objeto. En el siguiente ejemplo se muestra un evento que envió Amazon S3 cuando se cargó un paquete
de implementación en Amazon S3.

Example Evento de notificaciones de Amazon S3

{
"Records": [
{
"eventVersion": "2.1",
"eventSource": "aws:s3",
"awsRegion": "us-east-2",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "[Link]"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2":
"vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "lambda-artifacts-deafc19498e3f2df",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}

254
 AWS Lambda Guía para desarrolladores
Tutorial

}
]
}

Para invocar la función, Amazon S3 necesita permiso de la política basada en recursos (p. 36) de la
función. Al configurar un desencadenador de Amazon S3 en la consola de Lambda, esta modifica la
política basada en recursos para permitir a Amazon S3 invocar la función si el nombre del bucket y el ID
de cuenta coinciden. Si configura la notificación en Amazon S3, utilice la API de Lambda para actualizar
la política. También puede utilizar la API de Lambda para conceder permisos a otra cuenta o restringir el
permiso a un alias designado.

Si la función utiliza el SDK de AWS para administrar los recursos de Amazon S3, también necesita
permisos de Amazon S3 en su rol de ejecución (p. 32).

Temas
• Tutorial: uso de AWS Lambda con Amazon S3 (p. 255)
• Código de función de ejemplo de Amazon S3 (p. 261)
• Plantilla de AWS SAM para una aplicación de Amazon S3 (p. 267)

Tutorial: uso de AWS Lambda con Amazon S3

Supongamos que desea crear una miniatura para cada archivo que se carga en un bucket. Puede crear
una función de Lambda (CreateThumbnail) que Amazon S3 puede invocar cuando se crean objetos. El
código de la función de Lambda puede leer el objeto de imagen del bucket de origen y crear una imagen
en miniatura en el bucket de destino.

Al completar este tutorial, tendrá los siguientes recursos de Amazon S3, Lambda y IAM en su cuenta.

Recursos de Lambda

• Una función de Lambda.

• Una política de acceso asociada a la función de Lambda que da a Amazon S3 permiso para invocar la
función de Lambda.

255
 AWS Lambda Guía para desarrolladores
Tutorial

Recursos de IAM

• Un rol de ejecución que da permisos que la función de Lambda necesita a través de la política de
permisos asociada a este rol.

Recursos de Amazon S3

• Un bucket de origen con una configuración de notificación que invoca la función de Lambda.
• Un bucket de destino donde la función guarda las imágenes modificadas.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Instale NPM para administrar las dependencias de la función.

El tutorial utiliza comandos de la CLI de AWS para crear e invocar la función de Lambda. Instale la CLI de
AWS y configúrela con sus credenciales de AWS

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – AWS Lambda.

• Permissions (Permisos): AWSLambdaExecute.
• Role name (Nombre de rol): lambda-s3-role.

La política AWSLambdaExecute tiene permisos que la función necesita para administrar objetos en
Amazon S3 y escribir registros a CloudWatch Logs.

Crear buckets y subir un objeto de muestra

Siga los pasos para crear buckets y cargar un objeto.

256
 AWS Lambda Guía para desarrolladores
Tutorial

1. Abra la consola de Amazon S3.

2. Cree dos buckets. El nombre del bucket de destino debe ser source seguido de -resized.
donde source es el nombre del bucket que desea utilizar para el origen. Por ejemplo, mybucket y
mybucket-resized.
3. En el bucket de origen, cargue un objeto .jpg denominado [Link].

Al invocar la función de Lambda manualmente antes de conectarse a Amazon S3, debe pasar los datos
del evento de muestra a la función que especifica el bucket de origen, y [Link] como objeto
recién creado, por lo que necesita crear este objeto de muestra primero.

Creación de la función
El siguiente código de ejemplo recibe un evento de Amazon S3 y procesa el mensaje que contiene.
Modifica una imagen en el bucket de origen y guarda la salida en el bucket de destino.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de ejemplo de
Amazon S3 (p. 261).

Example [Link]

// dependencies
const AWS = require('aws-sdk');
const util = require('util');
const sharp = require('sharp');

// get reference to S3 client

const s3 = new AWS.S3();

[Link] = async (event, context, callback) => {

// Read options from the event parameter.

[Link]("Reading options from event:\n", [Link](event, {depth: 5}));
const srcBucket = [Link][0].[Link];
// Object key may have spaces or unicode non-ASCII characters.
const srcKey = decodeURIComponent([Link][0].[Link](/\+/g, "
"));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;

// Infer the image type from the file suffix.

const typeMatch = [Link](/\.([^.]*)$/);
if (!typeMatch) {
[Link]("Could not determine the image type.");
return;
}

// Check that the image type is supported

const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
[Link](`Unsupported image type: ${imageType}`);
return;
}

// Download the image from the S3 source bucket.

try {
const params = {
Bucket: srcBucket,
Key: srcKey

257
 AWS Lambda Guía para desarrolladores
Tutorial

};
var origimage = await [Link](params).promise();

} catch (error) {
[Link](error);
return;
}

// set thumbnail width. Resize will set the height automatically to maintain aspect
ratio.
const width = 200;

// Use the Sharp module to resize the image and save in a buffer.
try {
var buffer = await sharp([Link]).resize(width).toBuffer();

} catch (error) {
[Link](error);
return;
}

// Upload the thumbnail image to the destination bucket

try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: buffer,
ContentType: "image"
};

const putResult = await [Link](destparams).promise();

} catch (error) {
[Link](error);
return;
}

[Link]('Successfully resized ' + srcBucket + '/' + srcKey +

' and uploaded to ' + dstBucket + '/' + dstKey);
};

Revise el código anterior y observe lo siguiente:

• La función conoce el nombre del bucket de origen y el nombre de la clave de objeto a partir de los datos
del evento que recibe como parámetros. Si el objeto es una imagen .jpg o .png, el código crea una
miniatura y la guarda en el bucket de destino.
• El código presupone que el bucket de destino existe y que su nombre es una concatenación del nombre
del bucket de origen seguido por la cadena -resized. Por ejemplo, si el bucket de origen identificado
en los datos del evento es examplebucket, el código presupone que existe un bucket de destino
denominado examplebucket-resized.
• Para generar el nombre de la clave de la miniatura que crea, el código utiliza la cadena resized-
seguida del nombre de la clave del objeto de origen. Por ejemplo, si la clave del objeto de origen es
[Link], el código crea una objeto de miniatura cuya clave es [Link].

El paquete de implementación es un archivo .zip que contiene el código y las dependencias de la función
de Lambda.

Para crear un paquete de implementación

1. Guarde el código de la función como [Link] en una carpeta denominada lambda-s3.

2. Instale la biblioteca Sharp con npm. Para Linux, utilice el siguiente comando.

258
 AWS Lambda Guía para desarrolladores
Tutorial

lambda-s3$ npm install sharp

Para macOS, utilice el siguiente comando.

lambda-s3$ npm install --arch=x64 --platform=linux --target=12.13.0 sharp

Cuando realice este paso, tendrá la siguiente estructura de carpetas:

lambda-s3
|- [Link]
|- /node_modules/sharp
# /node_modules/...

3. Cree un paquete de implementación con el código de la función y las dependencias.

lambda-s3$ zip -r [Link] .

Para crear la función

• Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name CreateThumbnail \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/lambda-s3-role

En el caso del parámetro del rol, sustituya la secuencia numérica por el ID de la cuenta de AWS. El
comando del ejemplo anterior especifica un tiempo de espera de 10 segundos como configuración de la
función. En función del tamaño de los objetos que cargue, es posible que necesite para aumentar el tiempo
de espera utilizando el siguiente comando de la AWS CLI.

$ aws lambda update-function-configuration --function-name CreateThumbnail --timeout 30

Pruebe la función Lambda.

En este paso, invocará la función de Lambda de forma manual con los datos de un evento de muestra de
Amazon S3.

Para probar la función de Lambda

1. Guarde los siguientes datos del evento de muestra de Amazon S3 en un archivo denominado
[Link]. Deberá actualizar el JSON proporcionando el nombre de sourcebucket y una
clave de objeto .jpg.

{
"Records":[
{
"eventVersion":"2.0",
"eventSource":"aws:s3",
"awsRegion":"us-west-2",
"eventTime":"1970-01-01T00:00:00.000Z",
"eventName":"ObjectCreated:Put",
"userIdentity":{

259
 AWS Lambda Guía para desarrolladores
Tutorial

"principalId":"AIDAJDPLRKLG7UEXAMPLE"
},
"requestParameters":{
"sourceIPAddress":"[Link]"
},
"responseElements":{
"x-amz-request-id":"C3D13FE58DE4C810",
"x-amz-id-2":"FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD"
},
"s3":{
"s3SchemaVersion":"1.0",
"configurationId":"testConfigRule",
"bucket":{
"name":"sourcebucket",
"ownerIdentity":{
"principalId":"A3NL1KOZZKExample"
},
"arn":"arn:aws:s3:::sourcebucket"
},
"object":{
"key":"[Link]",
"size":1024,
"eTag":"d41d8cd98f00b204e9800998ecf8427e",
"versionId":"096fKKXTRTtl3on89fVO.nfljtsv6qko"
}
}
}
]
}

2. Ejecute el siguiente comando Lambda de la CLI de invoke para invocar la función. Tenga en
cuenta que el comando solicita la ejecución asíncrona. También puede invocarla de forma síncrona
especificando RequestResponse como valor del parámetro invocation-type.

$ aws lambda invoke --function-name CreateThumbnail --invocation-type Event \

--payload [Link] [Link]

3. Verifique que se crea la miniatura en el bucket de destino.

Configure Amazon S3 para publicar eventos.

En este paso, añadirá la configuración restante, de manera que Amazon S3 pueda publicar eventos de
creación de objetos en AWS Lambda e invocar la función de Lambda. En este paso, hará lo siguiente:

• Añadir permisos a la política de acceso de la función de Lambda para permitir que Amazon S3 invoque
la función.
• Añadir la configuración de notificaciones al bucket de origen. En la configuración de notificaciones, debe
proporcionar lo siguiente:
• Tipo de evento para el que desea que Amazon S3 publique eventos. Para este tutorial, debe
especificar el tipo de evento s3:ObjectCreated:* con objeto de que Amazon S3 publique eventos
cuando se creen objetos.
• Función de Lambda que se debe invocar.

Para añadir permisos a la política de función.

1. Ejecute el siguiente comando add-permission de la CLI de Lambda para conceder a la entidad

principal del servicio de Amazon S3 ([Link]) permisos para realizar la acción
lambda:InvokeFunction. Tenga en cuenta únicamente que se concede permiso a Amazon S3
para invocar la función si se cumplen las siguientes condiciones:

260
 AWS Lambda Guía para desarrolladores
Código de muestra

• Se detecta un evento de creación de objeto en un bucket específico.

• El bucket es propiedad de su cuenta. Si elimina un bucket, es posible que otra cuenta cree un
bucket con el mismo ARN.

$ aws lambda add-permission --function-name CreateThumbnail --principal

[Link] \
--statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::sourcebucket \
--source-account account-id

2. Verifique la política de acceso de la función ejecutando el comando get-policy de la AWS CLI.

$ aws lambda get-policy --function-name CreateThumbnail

Añada la configuración de notificaciones al bucket de origen para solicitar a Amazon S3 que publique los
eventos de creación de objetos en Lambda.
Important
Este procedimiento configura el bucket para invocar su función cada vez que se crea un objeto en
él. Asegúrese de configurar esta opción solo en el bucket de origen y no cree objetos en el bucket
de origen a partir de la función que se activa. De lo contrario, su función podría causar que se
invoque continuamente en bucle (p. 254).

Para configurar notificaciones

1. Abra la consola de Amazon S3.

2. Elija el bucket de origen
3. Seleccione Properties.
4. Bajo Eventos, configure una notificación con las siguientes especificaciones.

• Nombre – lambda-trigger.
• Eventos – ObjectCreate (All)
• Enviar – Lambda function
• Lambda – CreateThumbnail

Para obtener más información sobre la configuración de eventos, consulte Activar notificaciones de evento
en la Guía del usuario de la consola de Amazon Simple Storage Service.

Prueba de la configuración
Ahora puede probar la configuración como se indica a continuación:

1. Cargue objetos .jpg o .png en el bucket de origen mediante la consola de Amazon S3.
2. Verifique que se crea la miniatura en el bucket de destino mediante la función CreateThumbnail.
3. Ver registros en la consola de CloudWatch.

Código de función de ejemplo de Amazon S3

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas

261
 AWS Lambda Guía para desarrolladores
Código de muestra

• [Link] 12.x (p. 262)

• Java 11 (p. 264)
• Python 3 (p. 266)

[Link] 12.x
El siguiente código de ejemplo recibe un evento de Amazon S3 y procesa el mensaje que contiene.
Cambia el tamaño de una imagen en el bucket de origen y guarda la salida en el bucket de destino.

Example [Link]

// dependencies
const AWS = require('aws-sdk');
const util = require('util');
const sharp = require('sharp');

// get reference to S3 client

const s3 = new AWS.S3();

[Link] = async (event, context, callback) => {

// Read options from the event parameter.

[Link]("Reading options from event:\n", [Link](event, {depth: 5}));
const srcBucket = [Link][0].[Link];
// Object key may have spaces or unicode non-ASCII characters.
const srcKey = decodeURIComponent([Link][0].[Link](/\+/g, "
"));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;

// Infer the image type from the file suffix.

const typeMatch = [Link](/\.([^.]*)$/);
if (!typeMatch) {
[Link]("Could not determine the image type.");
return;
}

// Check that the image type is supported

const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
[Link](`Unsupported image type: ${imageType}`);
return;
}

// Download the image from the S3 source bucket.

try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var origimage = await [Link](params).promise();

} catch (error) {
[Link](error);
return;
}

// set thumbnail width. Resize will set the height automatically to maintain aspect
ratio.
const width = 200;

262
 AWS Lambda Guía para desarrolladores
Código de muestra

// Use the Sharp module to resize the image and save in a buffer.
try {
var buffer = await sharp([Link]).resize(width).toBuffer();

} catch (error) {
[Link](error);
return;
}

// Upload the thumbnail image to the destination bucket

try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: buffer,
ContentType: "image"
};

const putResult = await [Link](destparams).promise();

} catch (error) {
[Link](error);
return;
}

[Link]('Successfully resized ' + srcBucket + '/' + srcKey +

' and uploaded to ' + dstBucket + '/' + dstKey);
};

El paquete de implementación es un archivo .zip que contiene el código y las dependencias de la función
de Lambda.

Para crear un paquete de implementación

1. Cree una carpeta (examplefolder) y, a continuación, cree una subcarpeta (node_modules).

2. Instale las dependencias. Los ejemplos de código utilizan las siguientes bibliotecas:

• AWS SDK para JavaScript en [Link]

• Sharp para [Link]

El tiempo de ejecución de AWS Lambda ya tiene el SDK para JavaScript de AWS en [Link], por lo
que solo tiene que instalar la biblioteca Sharp. Abra un símbolo del sistema, vaya a examplefolder
e instale las bibliotecas utilizando el comando npm, que forma parte de [Link]. Para Linux, utilice el
siguiente comando.

$ npm install sharp

Para macOS, utilice el siguiente comando.

$ npm install --arch=x64 --platform=linux --target=12.13.0 sharp

3. Guarde el código de muestra en un archivo llamado [Link].

4. Revise el código anterior y observe lo siguiente:

• La función conoce el nombre del bucket de origen y el nombre de la clave de objeto a partir de los
datos del evento que recibe como parámetros. Si el objeto es una imagen .jpg, el código crea una
miniatura y la guarda en el bucket de destino.
• El código presupone que el bucket de destino existe y que su nombre es una concatenación del
nombre del bucket de origen seguido por la cadena -resized. Por ejemplo, si el bucket de origen

263
 AWS Lambda Guía para desarrolladores
Código de muestra

identificado en los datos del evento es examplebucket, el código presupone que existe un bucket
de destino denominado examplebucket-resized.
• Para generar el nombre de la clave de la miniatura que crea, el código utiliza la cadena resized-
seguida del nombre de la clave del objeto de origen. Por ejemplo, si la clave del objeto de origen es
[Link], el código crea una objeto de miniatura cuya clave es [Link].
5. Guarde el archivo como [Link] en examplefolder. Cuando realice este paso, tendrá la
siguiente estructura de carpetas:

[Link]
/node_modules/sharp

6. Comprima el archivo [Link] y la carpeta de módulos de nodo como [Link].

Java 11
A continuación, se muestra un ejemplo de código Java que lee los eventos entrantes de Amazon S3 y crea
una miniatura. Observe que implementa la interfaz RequestHandler proporcionada en la biblioteca aws-
lambda-java-core. Por lo tanto, en el momento de crear una función de Lambda debe especificar la
clase como controlador (es decir, [Link]). Para obtener más información acerca de cómo
utilizar interfaces para proporcionar un controlador, consulte Interfaces de controlador (p. 337).

El tipo S3Event utilizado por el controlador como tipo de entrada es una de las clases predefinidas en la
biblioteca aws-lambda-java-events que proporciona métodos para que se pueda leer fácilmente la
información del evento entrante de Amazon S3. El controlador devuelve una cadena como salida.

Example [Link]

package example;

import [Link];
import [Link].Graphics2D;
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

import [Link];
import [Link];
import [Link];
import [Link].S3Event;
import [Link].s3.AmazonS3;
import [Link].S3EventNotification.S3EventNotificationRecord;
import [Link];
import [Link];
import [Link].S3Object;
import [Link].s3.AmazonS3ClientBuilder;

public class Handler implements

RequestHandler<S3Event, String> {
private static final float MAX_WIDTH = 100;
private static final float MAX_HEIGHT = 100;
private final String JPG_TYPE = (String) "jpg";
private final String JPG_MIME = (String) "image/jpeg";
private final String PNG_TYPE = (String) "png";

264
 AWS Lambda Guía para desarrolladores
Código de muestra

private final String PNG_MIME = (String) "image/png";

public String handleRequest(S3Event s3event, Context context) {

try {
S3EventNotificationRecord record = [Link]().get(0);

String srcBucket = record.getS3().getBucket().getName();

// Object key may have spaces or unicode non-ASCII characters.

String srcKey = record.getS3().getObject().getUrlDecodedKey();

String dstBucket = srcBucket + "-resized";

String dstKey = "resized-" + srcKey;

// Sanity check: validate that source and destination are different

// buckets.
if ([Link](dstBucket)) {
[Link]
.println("Destination bucket must not match source bucket.");
return "";
}

// Infer the image type.

Matcher matcher = [Link](".*\\.([^\\.]*)").matcher(srcKey);
if (![Link]()) {
[Link]("Unable to infer image type for key "
+ srcKey);
return "";
}
String imageType = [Link](1);
if (!(JPG_TYPE.equals(imageType)) && !(PNG_TYPE.equals(imageType))) {
[Link]("Skipping non-image " + srcKey);
return "";
}

// Download the image from S3 into a stream

AmazonS3 s3Client = [Link]();
S3Object s3Object = [Link](new GetObjectRequest(
srcBucket, srcKey));
InputStream objectData = [Link]();

// Read the source image

BufferedImage srcImage = [Link](objectData);
int srcHeight = [Link]();
int srcWidth = [Link]();
// Infer the scaling factor to avoid stretching the image
// unnaturally
float scalingFactor = [Link](MAX_WIDTH / srcWidth, MAX_HEIGHT
/ srcHeight);
int width = (int) (scalingFactor * srcWidth);
int height = (int) (scalingFactor * srcHeight);

BufferedImage resizedImage = new BufferedImage(width, height,

BufferedImage.TYPE_INT_RGB);
Graphics2D g = [Link]();
// Fill with white before applying semi-transparent (alpha) images
[Link]([Link]);
[Link](0, 0, width, height);
// Simple bilinear resize
[Link](RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
[Link](srcImage, 0, 0, width, height, null);
[Link]();

// Re-encode image to target format

ByteArrayOutputStream os = new ByteArrayOutputStream();

265
 AWS Lambda Guía para desarrolladores
Código de muestra

[Link](resizedImage, imageType, os);

InputStream is = new ByteArrayInputStream([Link]());
// Set Content-Length and Content-Type
ObjectMetadata meta = new ObjectMetadata();
[Link]([Link]());
if (JPG_TYPE.equals(imageType)) {
[Link](JPG_MIME);
}
if (PNG_TYPE.equals(imageType)) {
[Link](PNG_MIME);
}

// Uploading to S3 destination bucket

[Link]("Writing to: " + dstBucket + "/" + dstKey);
try {
[Link](dstBucket, dstKey, is, meta);
}
catch(AmazonServiceException e)
{
[Link]([Link]());
[Link](1);
}
[Link]("Successfully resized " + srcBucket + "/"
+ srcKey + " and uploaded to " + dstBucket + "/" + dstKey);
return "Ok";
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}

Amazon S3 invoca la función de Lambda mediante el tipo de invocación Event, en el que AWS Lambda
ejecuta el código de forma asíncrona. No importa lo que se devuelva. Sin embargo, en este caso estamos
implementando una interfaz que obliga a especificar un tipo de retorno, por lo que en este ejemplo el
controlador utiliza String como tipo de retorno.

Dependencias.

• aws-lambda-java-core
• aws-lambda-java-events
• aws-java-sdk

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

Python 3
El siguiente código de ejemplo recibe un evento de Amazon S3 y procesa el mensaje que contiene.
Modifica una imagen en el bucket de origen y guarda la salida en el bucket de destino.

Example lambda_function.py

import boto3
import os
import sys
import uuid
from [Link] import unquote_plus
from PIL import Image
import [Link]

266
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

s3_client = [Link]('s3')

def resize_image(image_path, resized_path):

with [Link](image_path) as image:
[Link](tuple(x / 2 for x in [Link]))
[Link](resized_path)

def lambda_handler(event, context):

for record in event['Records']:
bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = [Link]('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), key)

Note

La biblioteca de imágenes que este código utiliza debe instalarse en un entorno Linux para crear
un paquete de implementación que funcione.

Para crear un paquete de implementación

1. Copie el código de muestra en un archivo con el nombre lambda_function.py.

2. Cree un entorno virtual.

s3-python$ virtualenv v-env

s3-python$ source v-env/bin/activate

3. Instale las bibliotecas en el entorno virtual.

(v-env) s3-python$ pip install Pillow boto3

4. Cree un paquete de implementación con el contenido de las bibliotecas instaladas.

(v-env) s3-python$ cd $VIRTUAL_ENV/lib/python3.8/site-packages

(v-env) python-s3/v-env/lib/python3.8/site-packages$ zip -r9 ${OLDPWD}/[Link] .

5. Agregue el código de controlador al paquete de implementación y desactive el entorno virtual.

(v-env) python-s3/v-env/lib/python3.8/site-packages$ cd ${OLDPWD}

(v-env) python-s3$ zip -g [Link] lambda_function.py
adding: lambda_function.py (deflated 55%)
(v-env) python-s3$ deactivate

Plantilla de AWS SAM para una aplicación de Amazon

S3
Puede construir esta aplicación utilizando AWS SAM. Para obtener más información sobre la creación
de plantillas AWS SAM, diríjase a AWS SAM Aspectos básicos sobre plantillas en la Guía para
desarrolladores deModelo de aplicación sin servidor de AWS.

A continuación, hay una plantilla AWS SAM de muestra para la aplicación de Lambda del
tutorial (p. 255). Copie el texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha

267
 AWS Lambda Guía para desarrolladores
Operaciones por lotes de Amazon S3

creado anteriormente. Tenga en cuenta que los valores de los parámetros Handler y Runtime deben
coincidir con los que utilizó cuando creó la función en la sección anterior.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
CreateThumbnail:
Type: AWS::Serverless::Function
Properties:
Handler: handler
Runtime: runtime
Timeout: 60
Policies: AWSLambdaExecute
Events:
CreateThumbnailEvent:
Type: S3
Properties:
Bucket: !Ref SrcBucket
Events: s3:ObjectCreated:*

SrcBucket:
Type: AWS::S3::Bucket

Para obtener más informaciónsobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

Uso de AWS Lambda con operaciones por lotes de

Amazon S3
Puede utilizar las operaciones por lotes de Amazon S3 para invocar una función Lambda en un conjunto
grande de objetos de Amazon S3. Amazon S3 realiza un seguimiento del progreso de las operaciones por
lotes, envía notificaciones y almacena un informe de finalización que muestra el estado de cada acción.

Para ejecutar una operación por lotes, cree untrabajo de operaciones por lotes de Amazon S3. Cuando se
crea el trabajo, se proporciona un manifiesto (la lista de objetos) y se configura la acción a realizar en esos
objetos.

Cuando se inicia el trabajo por lotes, Amazon S3 invoca la función Lambda sincrónicamente (p. 88) para
cada objeto del manifiesto. El parámetro de evento incluye los nombres del bucket y del objeto.

En el ejemplo siguiente se muestra el evento que Amazon S3 envía a la función Lambda de un objeto
denominado [Link] en el bucket awsexamplebucket .

Example Ejemplo de evento de solicitud por lotes de Amazon S3

{
"invocationSchemaVersion": "1.0",
"invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"job": {
"id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce"
},
"tasks": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"s3Key": "[Link]",

268
 AWS Lambda Guía para desarrolladores
Invocar funciones Lambda desde
operaciones por lotes de Amazon S3

"s3VersionId": "1",
"s3BucketArn": "arn:aws:s3:us-east-1:0123456788:awsexamplebucket"
}
]
}

Su función Lambda debe devolver un objeto JSON con los campos tal como se muestran en el siguiente
ejemplo. Puede copiar el parámetro invocationId y taskId desde el parámetro de evento. Puede
devolver una cadena en el resultString. Amazon S3 guarda los valores resultString en el informe
de finalización.

Example Respuesta de solicitud por lotes de Amazon S3

{
"invocationSchemaVersion": "1.0",
"treatMissingKeysAs" : "PermanentFailure",
"invocationId" : "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"results": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"resultCode": "Succeeded",
"resultString": "["Alice", "Bob"]"
}
]
}

Invocar funciones Lambda desde operaciones por

lotes de Amazon S3
Puede invocar la función Lambda con el ARN de una función no calificada o calificada. Si desea utilizar la
misma versión de una función para todo el trabajo por lotes, configure una versión de función específica
en el parámetro FunctionARN cuando cree el trabajo. Si configura un alias o el calificador $LATEST, el
trabajo por lotes comienza inmediatamente a llamar a la nueva versión de la función si el alias o $LATEST
se actualizan durante la ejecución del trabajo.

Tenga en cuenta que no puede reutilizar una función Amazon S3 basada en eventos existente para
operaciones por lotes. Esto se debe a que la operación por lotes de Amazon S3 pasa un parámetro de
evento diferente a la función Lambda y espera un mensaje de retorno con una estructura JSON específica.

En la política basada en recursos (p. 36) que cree para el trabajo por lotes de Amazon S3, asegúrese de
establecer permisos para que el trabajo invoque su función Lambda.

En el rol de ejecución (p. 32) de la función, establezca una política de confianza de Amazon S3 para
asumir el rol cuando ejecute la función.

Si su función utiliza SDK de AWS para administrar recursos de Amazon S3, debe agregar permisos de
Amazon S3 a la función de ejecución.

Cuando se ejecuta el trabajo, Amazon S3 inicia varias instancias de función para procesar los objetos de
Amazon S3 en paralelo, hasta el límite de concurrencia (p. 102) de la función. Amazon S3 limita el avance
inicial de instancias para evitar un costo excesivo para trabajos más pequeños.

Si la función Lambda devuelve un código de respuesta TemporaryFailure, Amazon S3 reintenta la

operación.

Para obtener más información acerca de las operaciones por lotes de Amazon S3, consulte Realización de
operaciones por lotes en la Guía del desarrollador de Amazon S3.

269
 AWS Lambda Guía para desarrolladores
Amazon SES

Para obtener un ejemplo de cómo utilizar una función Lambda en operaciones por lotes de Amazon
S3, consulte Invocar una función Lambda en las operaciones por lotes de Amazon S3 en la Guía del
desarrollador de Amazon S3.

Uso de AWS Lambda con Amazon SES

Si utiliza Amazon SES para recibir mensajes, puede configurar Amazon SES para que llame a una función
de Lambda cuando lleguen mensajes. El servicio puede invocar la función de Lambda pasándole como
parámetro el evento de correo electrónico entrante, que en realidad es un mensaje de Amazon SES en un
evento de Amazon SNS.

Example Evento de mensaje de Amazon SES

{
"Records": [
{
"eventVersion": "1.0",
"ses": {
"mail": {
"commonHeaders": {
"from": [
"Jane Doe <janedoe@[Link]>"
],
"to": [
"johndoe@[Link]"
],
"returnPath": "janedoe@[Link]",
"messageId": "<[Link]>",
"date": "Wed, 7 Oct 2015 12:34:56 -0700",
"subject": "Test Subject"
},
"source": "janedoe@[Link]",
"timestamp": "1970-01-01T00:00:00.000Z",
"destination": [
"johndoe@[Link]"
],
"headers": [
{
"name": "Return-Path",
"value": "<janedoe@[Link]>"
},
{
"name": "Received",
"value": "from [Link] ([Link] [[Link]]) by
[Link] with SMTP id o3vrnil0e2ic for johndoe@[Link];
Wed, 07 Oct 2015 12:34:56 +0000 (UTC)"
},
{
"name": "DKIM-Signature",
"value": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=[Link];
s=example; h=mime-version:from:date:message-id:subject:to:content-type;
bh=jX3F0bCAI7sIbkHyy3mLYO28ieDQz2R0P8HwQkklFj4=; b=sQwJ+LMe9RjkesGu+vqU56asvMhrLRRYrWCbV"
},
{
"name": "MIME-Version",
"value": "1.0"
},
{
"name": "From",
"value": "Jane Doe <janedoe@[Link]>"
},
{

270
 AWS Lambda Guía para desarrolladores
Amazon SNS

"name": "Date",
"value": "Wed, 7 Oct 2015 12:34:56 -0700"
},
{
"name": "Message-ID",
"value": "<[Link]>"
},
{
"name": "Subject",
"value": "Test Subject"
},
{
"name": "To",
"value": "johndoe@[Link]"
},
{
"name": "Content-Type",
"value": "text/plain; charset=UTF-8"
}
],
"headersTruncated": false,
"messageId": "o3vrnil0e2ic28tr"
},
"receipt": {
"recipients": [
"johndoe@[Link]"
],
"timestamp": "1970-01-01T00:00:00.000Z",
"spamVerdict": {
"status": "PASS"
},
"dkimVerdict": {
"status": "PASS"
},
"processingTimeMillis": 574,
"action": {
"type": "Lambda",
"invocationType": "Event",
"functionArn": "arn:aws:lambda:us-west-2:012345678912:function:Example"
},
"spfVerdict": {
"status": "PASS"
},
"virusVerdict": {
"status": "PASS"
}
}
},
"eventSource": "aws:ses"
}
]
}

Para obtener más información, consulte Acción de Lambda en la Guía para desarrolladores de Amazon
SES.

Uso de AWS Lambda con Amazon SNS

Puede utilizar una función Lambda para procesar notificaciones de Amazon Simple Notification Service.
Amazon SNS admite funciones Lambda como destino para los mensajes enviados a un tema. Puede
suscribir la función a temas de la misma cuenta o de otras cuentas de AWS.

271
 AWS Lambda Guía para desarrolladores
Amazon SNS

Amazon SNS invoca la función de forma asíncrona (p. 89) con un evento que contiene un mensaje y
metadatos.

Example Evento de mensaje de Amazon SNS

{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-
a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"Signature": "tcc6faL2yUC6dgZdmrwh1Y4cGa/ebXEkAi6RibDsvpi+tE/1+82j...65r==",
"SigningCertUrl": "[Link]
[Link]",
"MessageId": "95df01b4-ee98-5cb9-9903-4c221d41eb5e",
"Message": "Hello from SNS!",
"MessageAttributes": {
"Test": {
"Type": "String",
"Value": "TestString"
},
"TestBinary": {
"Type": "Binary",
"Value": "TestBinary"
}
},
"Type": "Notification",
"UnsubscribeUrl": "[Link]
Action=Unsubscribe&amp;SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-
lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "TestInvoke"
}
}
]
}

Para la invocación asíncrona, Lambda pone en cola el mensaje y gestiona los reintentos. Si Amazon
SNS no puede conectar con Lambda o el mensaje se rechaza, lo Amazon SNS reintenta la operación a
intervalos cada vez mayores durante varias horas. Para obtener más información, consulte Fiabilidad en
las preguntas frecuentes de Amazon SNS.

Para poder realizar entregas de Amazon SNS a Lambda entre distintas cuentas, debe autorizar la
invocación de la función de Lambda desde Amazon SNS. A su vez, Amazon SNS debe permitir que la
cuenta de Lambda se suscriba al tema de Amazon SNS. Por ejemplo, si el tema de Amazon SNS está en
la cuenta A y la función de Lambda está en la cuenta B, cada cuenta debe conceder permisos a la otra
para que acceda a sus recursos. Dado que en la consola de AWS no están disponibles todas las opciones
para configurar permisos entre cuentas, se utiliza la CLI de AWS para configurar todo el proceso.

Para obtener más información, consulte Invocación de funciones de Lambda mediante las notificaciones de
Amazon SNS en la Guía para desarrolladores de Amazon Simple Notification Service.

Temas
• Tutorial: uso de AWS Lambda con Amazon Simple Notification Service (p. 273)
• Código de función de muestra (p. 275)

272
 AWS Lambda Guía para desarrolladores
Tutorial

Tutorial: uso de AWS Lambda con Amazon Simple

Notification Service
Puede utilizar una función de Lambda en una cuenta de AWS para suscribirse a un tema de Amazon
SNS de otra cuenta de AWS. En este tutorial, se utiliza la AWS Command Line Interface para realizar
operaciones de AWS Lambda, como, por ejemplo, la creación de una función de Lambda, la creación de
un tema de Amazon SNS y la concesión de permisos permitir que estos dos recursos puedan acceder el
uno al otro.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

En el tutorial, se utilizarán dos cuentas. Los comandos de la AWS CLI ilustran esto utilizando dos perfiles
con nombre, cada uno configurado para el uso con una cuenta diferente. Si utiliza perfiles con nombres
distintos, bien el perfil predeterminado o un perfil con nombre, modifique los comandos según sea
necesario.

Crear un tema de Amazon SNS

Desde la cuenta A, cree el tema de Amazon SNS de origen.

$ aws sns create-topic --name lambda-x-account --profile accountA

Anote el ARN del tema que devuelve el comando. Lo necesitará cuando añada permisos a la función de
Lambda para suscribirse al tema.

Creación del rol de ejecución

Desde la cuenta B, cree el rol de ejecución (p. 32) que da a la función permiso para acceder a los recursos
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – AWS Lambda.

273
 AWS Lambda Guía para desarrolladores
Tutorial

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-sns-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Creación de una función Lambda

Desde la cuenta B, cree la función que procesa los eventos desde Amazon SNS. A continuación se
muestra código de ejemplo que recibe un evento de Amazon SNS como entrada y procesa los mensajes
que contiene. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada en
CloudWatch Logs.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 275).

Example [Link]

[Link]('Loading function');

[Link] = function(event, context, callback) {

// [Link]('Received event:', [Link](event, null, 4));

var message = [Link][0].[Link];

[Link]('Message received from SNS:', message);
callback(null, "Success");
};

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name SNS-X-Account \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::01234567891B:role/service-role/lambda-sns-execution-role \
--timeout 60 --profile accountB

Anote el ARN de la función que devuelve el comando. Lo necesitará cuando añada permisos para permitir
a Amazon SNS que invoque la función.

Configuración de los permisos entre las cuentas

Desde la cuenta A, conceda permiso para que la cuenta B se suscriba al tema:

$ aws sns add-permission --label lambda-access --aws-account-id 12345678901B \

--topic-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--action-name Subscribe ListSubscriptionsByTopic Receive --profile accountA

Desde la cuenta B añada el permiso de Lambda para permitir la invocación desde Amazon SNS.

274
 AWS Lambda Guía para desarrolladores
Código de muestra

$ aws lambda add-permission --function-name SNS-X-Account \

--source-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--statement-id sns-x-account --action "lambda:InvokeFunction" \
--principal [Link] --profile accountB
{
"Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:us-
east-2:12345678901B:function:SNS-X-Account\"}},\"Action\":[\"lambda:InvokeFunction\"],
\"Resource\":\"arn:aws:lambda:us-east-2:01234567891A:function:SNS-X-Account\",\"Effect\":
\"Allow\",\"Principal\":{\"Service\":\"[Link]\"},\"Sid\":\"sns-x-account1\"}"
}

No utilice el parámetro --source-account para añadir una cuenta de origen a la política de Lambda al
añadir la política. La cuenta de origen no es compatible con los orígenes de eventos de Amazon SNS y
dará lugar a la denegación de acceso.

Crear una suscripción

Desde la cuenta B, suscriba la función de Lambda al tema. Cuando se envía un mensaje al lambda-x-
account tema en la cuenta A, Amazon SNS invoca la SNS-X-Account función en la cuenta B.

$ aws sns subscribe --protocol lambda \

--topic-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--notification-endpoint arn:aws:lambda:us-east-2:12345678901B:function:SNS-X-Account \
--profile accountB
{
"SubscriptionArn": "arn:aws:sns:us-east-2:12345678901A:lambda-x-
account:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}

La salida contiene el ARN de la suscripción al tema.

Prueba de la suscripción
Desde la cuenta A, pruebe la suscripción. Escriba Hello World en un archivo de texto y guárdelo como
[Link]. A continuación, ejecute el siguiente comando:

$ aws sns publish --message [Link] --subject Test \

--topic-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--profile accountA

Esto devolverá un ID de mensaje con un identificador único que indica que el servicio Amazon SNS aceptó
el mensaje. A continuación, Amazon SNS intentará entregarlo a los suscriptores del tema. También puede
proporcionar una cadena JSON directamente al parámetro message, pero si utiliza un archivo de texto,
puede incluir saltos de línea en el mensaje.

Para obtener más información sobre Amazon SNS, consulte ¿Qué es Amazon Simple Notification Service?

Código de función de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• [Link] 8 (p. 276)
• Java 11 (p. 276)
• Go (p. 277)

275
 AWS Lambda Guía para desarrolladores
Código de muestra

• Python 3 (p. 277)

[Link] 8
En el siguiente ejemplo, se procesan los mensajes de Amazon SNS, y registra su contenido.

Example [Link]

[Link]('Loading function');

[Link] = function(event, context, callback) {

// [Link]('Received event:', [Link](event, null, 4));

var message = [Link][0].[Link];

[Link]('Message received from SNS:', message);
callback(null, "Success");
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

Java 11
En el siguiente ejemplo, se procesan los mensajes de Amazon SNS, y registra su contenido.

Example [Link]

package example;

import [Link];
import [Link];

import [Link];
import [Link];
import [Link];

public class LogEvent implements RequestHandler<SNSEvent, Object> {

public Object handleRequest(SNSEvent request, Context context){
String timeStamp = new SimpleDateFormat("yyyy-MM-
dd_HH:mm:ss").format([Link]().getTime());
[Link]().log("Invocation started: " + timeStamp);
[Link]().log([Link]().get(0).getSNS().getMessage());

timeStamp = new SimpleDateFormat("yyyy-MM-

dd_HH:mm:ss").format([Link]().getTime());
[Link]().log("Invocation completed: " + timeStamp);
return null;
}
}

Dependencias.

• aws-lambda-java-core
• aws-lambda-java-events

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

276
 AWS Lambda Guía para desarrolladores
Amazon SQS

Go
En el siguiente ejemplo, se procesan los mensajes de Amazon SNS, y registra su contenido.

Example lambda_handler.go

package main

import (
"context"
"fmt"
"[Link]/aws/aws-lambda-go/lambda"
"[Link]/aws/aws-lambda-go/events"
)

func handler(ctx [Link], snsEvent [Link]) {

for _, record := range [Link] {
snsRecord := [Link]
[Link]("[%s %s] Message = %s \n", [Link], [Link],
[Link])
}
}

func main() {
[Link](handler)
}

Compile el ejecutable con go build y cree un paquete de implementación. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en Go (p. 359).

Python 3
En el siguiente ejemplo, se procesan los mensajes de Amazon SNS, y registra su contenido.

Example lambda_handler.py

from __future__ import print_function

import json
print('Loading function')

def lambda_handler(event, context):

#print("Received event: " + [Link](event, indent=2))
message = event['Records'][0]['Sns']['Message']
print("From SNS: " + message)
return message

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Uso de AWS Lambda con Amazon SQS

Puede usar una función AWS Lambda para procesar mensajes en una cola Amazon Simple Queue
Service (Amazon SQS). Las asignaciones de origen de eventos (p. 97) de Lambda admiten colas estándar
y colas de primero en entrar, primero en salir (FIFO). Con Amazon SQS, puede descargar tareas de
un componente de su aplicación enviándolas a una cola para, a continuación, procesarlas de forma
asíncrona.

277
 AWS Lambda Guía para desarrolladores
Amazon SQS

Lambda sondea la cola e invoca la función sincrónicamente (p. 88) con un evento que contenga mensajes
de cola. Lambda lee mensajes en lotes e invoca la función una vez por lote. Cuando la función procesa
correctamente un lote, Lambda elimina sus mensajes de la cola. En el ejemplo siguiente se muestra un
evento para un lote de dos mensajes.

Example Evento de mensaje de Amazon SQS (cola estándar)

{
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "Test message.",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185"
},
"messageAttributes": {},
"md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"awsRegion": "us-east-2"
},
{
"messageId": "2e1424d4-f796-459a-8184-9c92662be6da",
"receiptHandle": "AQEBzWwaftRI0KuVm4tP+/7q1rGgNqicHq...",
"body": "Test message.",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082650636",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082650649"
},
"messageAttributes": {},
"md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"awsRegion": "us-east-2"
}
]
}

Para las colas FIFO, los registros contienen atributos adicionales relacionados con la deduplicación y la
secuenciación.

Example Evento de mensaje de Amazon SQS (cola FIFO)

{
"Records": [
{
"messageId": "11d6ee51-4cc7-4302-9e22-7cd8afdaadf5",
"receiptHandle": "AQEBBX8nesZEXmkhsmZeyIE8iQAMig7qw...",
"body": "Test message.",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1573251510774",
"SequenceNumber": "18849496460467696128",
"MessageGroupId": "1",
"SenderId": "AIDAIO23YVJENQZJOL4VO",
"MessageDeduplicationId": "1",
"ApproximateFirstReceiveTimestamp": "1573251510774"

278
 AWS Lambda Guía para desarrolladores
Escalado y procesamiento

},
"messageAttributes": {},
"md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:[Link]",
"awsRegion": "us-east-2"
}
]
}

Cuando Lambda lee un lote, los mensajes se mantienen en la cola, pero se ocultan durante el tiempo de
espera de visibilidad de la cola. Cuando la función procesa correctamente un lote, Lambda elimina sus
mensajes de la cola. Si la función se limita (p. 102), devuelve un error o no responde, el mensaje se hace
visible de nuevo. Todos los mensajes de un lote con errores volverán a la cola, por lo que el código de su
función debe ser capaz de procesar el mismo mensaje varias veces sin efectos secundarios.

Escalado y procesamiento
Para las colas estándar, Lambda utiliza el sondeo largo para sondear una cola hasta que se active.
Cuando los mensajes están disponibles, Lambda lee hasta 5 lotes y los envía a su función. Si los mensajes
siguen estando disponibles, Lambda aumenta el número de procesos que son lotes de lectura hasta 60
instancias más por minuto. El número máximo de lotes que se pueden procesar simultáneamente mediante
un mapeo de origen de eventos es 1000.

Para colas FIFO, Lambda envía mensajes a su función en el orden en que los recibe. Cuando se envía
un mensaje a una cola FIFO, se especifica un ID de grupo de mensajes. Amazon SQS garantiza que los
mensajes del mismo grupo se entreguen a Lambda en orden. Lambda ordena los mensajes en grupos y
envía sólo un lote a la vez por grupo. Si la función devuelve un error, todos los reintentos se realizan en los
mensajes afectados antes de que Lambda reciba mensajes adicionales del mismo grupo.

Su función puede escalar simultáneamente al número de grupos de mensajes activos. Para obtener más
información, consulte SQS FIFO como fuente de eventos en el blog de informática de AWS.

Configuración de una cola para el uso con Lambda

Cree una cola de SQS estándar que sirva como origen de eventos para la función de Lambda. A
continuación, configure la cola para dar tiempo a su función de Lambda a procesar cada lote de eventos—
y para que Lambda vuelva a actuar en respuesta a los errores de limitación a medida que aumenta.

Para dar tiempo al tiempo de función a procesar cada lote de registros, configure el tiempo de espera de
la visibilidad de la cola hasta al menos 6 veces el tiempo de espera (p. 52) que configure en su función. El
tiempo adicional permitirá a Lambda volver a intentar realizar los procesos en caso de que la ejecución de
la función se vea limitada debido al procesamiento de un lote anterior.

Si el procesamiento de un mensaje da error repetidas veces, Amazon SQS podrá enviar dicho mensaje a
una cola de mensajes fallidos. Cuando su función devuelve un error, Lambda lo deja en la cola. Después
de que se supera el tiempo de espera de visibilidad, Lambda recibe el mensaje de nuevo. Para enviar
mensajes a una segunda cola después de recibir varias veces, configure una cola de mensajes fallidos en
la cola de origen.
Note
Asegúrese de configurar la cola de mensajes fallidos en la cola de origen y no en la función de
Lambda. La cola de mensajes fallidos que configure en una función se utiliza para la cola de
invocación asíncrona (p. 89) de la función, no para las colas de origen de eventos.

Si la función devuelve un error o no puede invocarse porque está en la máxima simultaneidad, es

posible que el procesado tenga éxito tras algunos intentos adicionales. Para dar a los mensajes una
oportunidad mejor de ser procesados antes de enviarlos a la cola de mensajes fallidos, establezca el
maxReceiveCount de la política de redirección de la cola de origen a como mínimo 5.

279
 AWS Lambda Guía para desarrolladores
Permisos de rol de ejecución

Permisos de rol de ejecución

Lambda necesita los permisos siguientes para poder administrar mensajes en la cola de Amazon SQS.
Añada dichos permisos al rol de ejecución de su función.

• sqs:ReceiveMessage
• sqs:DeleteMessage
• sqs:GetQueueAttributes

Para obtener más información, consulte Rol de ejecución de AWS Lambda (p. 32).

Configuración de una cola como origen de eventos

Cree un mapeo de origen de eventos para indicar a Lambda que envíe elementos desde una cola a una
función de Lambda. Puede crear varios mapeos de orígenes de eventos para procesar elementos de
varias colas con una sola función. Cuando Lambda invoca la función objetivo, el evento puede contener
múltiples elementos, dependiendo del tamaño de lote máximo configurable.

Para configurar la función para leer de Amazon SQS en la consola de Lambda, cree un desencadenador
de SQS.

Para crear un disparador

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En Designer (Diseñador), elija Add trigger (Añadir disparador).
4. Elija un tipo de disparador.
5. Configure las opciones necesarias y, a continuación, elija Add (Añadir).

Lambda admite las siguientes opciones para los orígenes de eventos de Amazon SQS.

Opciones de origen de eventos

• SQS queue (Cola de SQS): la cola de Amazon SQS desde la que leer registros.
• Batch size (Tamaño del lote): el número de elementos que leer de la cola en cada lote, hasta 10. El
evento podría contener menos elementos si el lote que Lambda lee de la cola tuviera menos elementos.
• Enabled (Habilitado): deshabilite el origen de eventos para detener el procesamiento de elementos.

Para administrar la configuración de origen de evento más tarde, elija el desencadenador en el diseñador.

Configure el tiempo de espera de la función para que disponga de tiempo suficiente para procesar todo
un lote de elementos. Si elementos tardan mucho tiempo en procesarse, elija un tamaño de lote más
pequeño. Un tamaño de lote amplio puede mejorar la eficiencia para cargas de trabajo que son muy
rápidas o tienen mucha administración. Sin embargo, si la función devuelve un error, todos los elementos
del lote vuelven a la cola. Si configura la simultaneidad reservada (p. 59) en la función, establezca al
menos 5 ejecuciones simultáneas para reducir la posibilidad de errores de límite cuando Lambda invoque
la función.

API de mapeo de origen de eventos

Para administrar las asignaciones de orígenes de eventos con la AWS CLI o el SDK de AWS, utilice las
siguientes acciones de la API:

280
 AWS Lambda Guía para desarrolladores
Tutorial

• CreateEventSourceMapping (p. 460)

• ListEventSourceMappings (p. 537)
• GetEventSourceMapping (p. 496)
• UpdateEventSourceMapping (p. 592)
• DeleteEventSourceMapping (p. 477)

En el siguiente ejemplo se utiliza la AWS CLI para asignar una función llamada my-function a una cola
de Amazon SQS especificada mediante su nombre de recurso de Amazon (ARN), con un tamaño de lote
de 5.

$ aws lambda create-event-source-mapping --function-name my-function --batch-size 5 \

--event-source-arn arn:aws:sqs:us-east-2:123456789012:my-queue
{
"UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284",
"BatchSize": 5,
"EventSourceArn": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"LastModified": 1541139209.351,
"State": "Creating",
"StateTransitionReason": "USER_INITIATED"
}

Tutorial: uso de AWS Lambda con Amazon Simple

Queue Service
En este tutorial, debe crear una función de Lambda para consumir mensajes de una cola Amazon SQS.

Requisitos previos
En este tutorial, se le presuponen algunos conocimientos sobre las operaciones básicas de Lambda y la
consola de Lambda. Si aún no lo ha hecho, siga las instrucciones que se indican en Introducción a AWS
Lambda (p. 3) para crear la primera función de Lambda.

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Creación del rol de ejecución

Cree el rol de ejecución (p. 32) que concederá a su función permiso para obtener acceso a los recursos de
AWS.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).

281
 AWS Lambda Guía para desarrolladores
Tutorial

3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – AWS Lambda.

• Permissions (Permisos) – AWSLambdaSQSQueueExecutionRole.
• Role name (Nombre de rol): lambda-sqs-role.

La política AWSLambdaSQSQueueExecutionRole tiene permisos que la función necesita para leer

elementos de Amazon SQS y escribir registros a CloudWatch Logs.

Creación de la función
A continuación se muestra código de ejemplo que recibe un evento de Amazon SQS como entrada y
procesa los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los
eventos de entrada en CloudWatch Logs.
Note

Para ver código de muestra en otros lenguajes, consulte Código de función Amazon SQS de
muestra (p. 284).

Example [Link]

[Link] = async function(event, context) {

[Link](record => {
const { body } = record;
[Link](body);
});
return {};
}

Para crear la función

1. Copie el código de muestra en un archivo con el nombre [Link].

2. Crear un paquete de implementación.

$ zip [Link] [Link]

3. Cree una función de Lambda con el comando create-function.

$ aws lambda create-function --function-name ProcessSQSRecord \

--zip-file fileb://[Link] --handler [Link] --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-sqs-role

Prueba de la función
Invoque la función de Lambda manualmente mediante el comando invoke de la CLI de AWS Lambda y
un evento de Amazon Simple Queue Service de muestra.

Si el controlador vuelve normalmente sin excepciones, Lambda considera que el mensaje se ha procesado
correctamente y empieza a leer nuevos mensajes en la cola. Una vez que un mensaje se procesa
correctamente, se elimina automáticamente de la cola. Si el controlador genera una excepción, Lambda
considera que la entrada de mensajes no se ha procesado e invoca de nuevo la función con el mismo lote
de mensajes.

1. Copie el siguiente JSON en un archivo y guárdelo como [Link].

282
 AWS Lambda Guía para desarrolladores
Tutorial

{
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "test",
"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185"
},
"messageAttributes": {},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"awsRegion": "us-east-2"
}
]
}

2. Ejecute el siguiente comando invoke.

$ aws lambda invoke --function-name ProcessSQSRecord \

--payload [Link] [Link]

3. Verifique la salida en el archivo [Link].

Creación de una cola de Amazon SQS.

Cree una cola de Amazon SQS que la función de Lambda pueda utilizar como origen de eventos.

Para crear una cola

1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon SQS en https://
[Link]/sqs/.
2. En la consola de Amazon SQS, cree una cola.
3. Escriba o registre el ARN (nombre del recurso de Amazon) de la cola de identificación. Lo necesitará
en el siguiente paso al asociar la cola a la función Lambda.

Crear un mapeo de origen de eventos en AWS Lambda. Este mapeo de origen de eventos asocia la cola
de Amazon SQS a la función de Lambda. Una vez creado este mapeo de origen de eventos, AWS Lambda
comienza a sondear la cola.

Probar la experiencia integral. A medida que se actualiza la cola, Amazon Simple Queue Service escribe
mensajes en la cola. AWS Lambda sondea la cola, detecta nuevos registros y ejecuta la función de
Lambda en su nombre pasando los eventos a la función, en este caso mensajes de Amazon SQS.

Configuración del origen de eventos

Para crear un mapeo entre la cola de Amazon SQS especificada y la función de Lambda, ejecute el
comando create-event-source-mapping de la AWS CLI. Después de ejecutar el comando, anote
o registre el UUID. Necesitará este UUID para hacer referencia al mapeo de origen de eventos en otros
comandos, por ejemplo, si decide eliminar el mapeo de origen de eventos.

$ aws lambda create-event-source-mapping --function-name ProcessSQSRecord --batch-size 10

\

283
 AWS Lambda Guía para desarrolladores
Código de muestra

--event-source-arn arn:aws:sqs:us-east-2:123456789012:my-queue

Para obtener la lista de mapeos de orígenes de eventos, ejecute el siguiente comando.

$ aws lambda list-event-source-mappings --function-name ProcessSQSRecord \

--event-source-arn arn:aws:sqs:us-east-2:123456789012:my-queue

La lista devuelve todos los mapeos de orígenes de eventos creados, y para cada uno de ellos muestra
el LastProcessingResult, entre otras cosas. Este campo se utiliza para proporcionar un mensaje
informativo en caso de que surja algún problema. Los valores como No records processed (indica
que AWS Lambda no ha comenzado el sondeo o que no hay registros en la cola) y OK (indica que AWS
Lambda ha leído correctamente los registros de la cola y ha invocado la función de Lambda) indican que
no hay ningún problema. Si hay algún problema, recibirá un mensaje de error.

Prueba de la configuración
Ahora puede probar la configuración como se indica a continuación:

1. En la consola de Amazon SQSpuede enviar mensajes a la cola. Amazon SQS escribe registros de estas
acciones en la cola.
2. AWS Lambda sondea la cola y, cuando detecta actualizaciones, invoca la función de Lambda pasando
los datos de eventos que encuentra en la cola.
3. La función ejecuta y crea logs en Amazon CloudWatch. Puede verificar los registros reportados en la
consola de Amazon CloudWatch.

Código de función Amazon SQS de muestra

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• [Link] (p. 284)
• Java (p. 285)
• C# (p. 285)
• Go (p. 286)
• Python (p. 287)

[Link]
A continuación se muestra código de ejemplo que recibe un mensaje de evento de Amazon SQS como
entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada
en CloudWatch Logs.

Example [Link] ([Link] 8)

[Link] = async function(event, context) {

[Link](record => {
const { body } = record;
[Link](body);
});
return {};
}

284
 AWS Lambda Guía para desarrolladores
Código de muestra

Example [Link] ([Link] 6)

[Link](function(record) {
var body = [Link];
[Link](body);
});
callback(null, "message");
};

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación AWS Lambda en [Link] (p. 292).

Java
A continuación se muestra código Java de ejemplo que recibe un mensaje de evento de Amazon SQS
como entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.

En el código, handleRequest es el controlador. Este controlador utiliza la clase SQSEvent predefinida,

que se define en la biblioteca aws-lambda-java-events.

Example [Link]

package example;

import [Link];
import [Link];
import [Link];
import [Link];

public class Handler implements RequestHandler<SQSEvent, Void>{

@Override
public Void handleRequest(SQSEvent event, Context context)
{
for(SQSMessage msg : [Link]()){
[Link](new String([Link]()));
}
return null;
}
}

Dependencias.

• aws-lambda-java-core
• aws-lambda-java-events

Cree el código con las dependencias de la biblioteca de Lambda para crear un paquete de
implementación. Para obtener instrucciones, consulte Paquete de implementación AWS Lambda en
Java (p. 329).

C#
A continuación se muestra código C# de ejemplo que recibe un mensaje de evento de Amazon SQS como
entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada
en la consola.

En el código, handleRequest es el controlador. Este controlador utiliza la clase SQSEvent predefinida,

que se define en la biblioteca [Link].

285
 AWS Lambda Guía para desarrolladores
Código de muestra

Example [Link]

[assembly: LambdaSerializer(typeof([Link]))]

namespace SQSLambdaFunction
{
public class SQSLambdaFunction
{
public string HandleSQSEvent(SQSEvent sqsEvent, ILambdaContext context)
{
[Link]($"Beginning to process {[Link]} records...");

foreach (var record in [Link])

{
[Link]($"Message ID: {[Link]}");
[Link]($"Event Source: {[Link]}");

[Link]($"Record Body:");
[Link]([Link]);
}

[Link]("Processing complete.");

return $"Processed {[Link]} records.";

}
}
}

Reemplace [Link] en un proyecto .NET Core con el ejemplo anterior. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en C# (p. 372).

Go
A continuación se muestra código Go de ejemplo que recibe un mensaje de evento de Amazon SQS como
entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada
en CloudWatch Logs.

En el código, handler es el controlador. Este controlador utiliza la clase SQSEvent predefinida, que se
define en la biblioteca aws-lambda-go-events.

Example [Link]

package main

import (
"context"
"fmt"

"[Link]/aws/aws-lambda-go/events"
"[Link]/aws/aws-lambda-go/lambda"
)

func handler(ctx [Link], sqsEvent [Link]) error {

for _, message := range [Link] {
[Link]("The message %s for event source %s = %s \n", [Link],
[Link], [Link])
}

return nil
}

func main() {

286
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

[Link](handler)
}

Compile el ejecutable con go build y cree un paquete de implementación. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en Go (p. 359).

Python
A continuación se muestra código de ejemplo de Python que acepta un registro de Amazon SQS como
entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada
en CloudWatch Logs.

Siga las instrucciones para crear un paquete de implementación para la función de AWS Lambda.

Example [Link]

from __future__ import print_function

def lambda_handler(event, context):

for record in event['Records']:
print ("test")
payload=record["body"]
print(str(payload))

Comprima el código de muestra para crear un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Python (p. 304).

Plantilla de AWS SAM para una aplicación de Amazon

SQS
Puede construir esta aplicación utilizando AWS SAM. Para obtener más información sobre la creación
de plantillas AWS SAM, diríjase a AWS SAM Aspectos básicos sobre plantillas en la Guía para
desarrolladores deModelo de aplicación sin servidor de AWS.

A continuación, hay una plantilla AWS SAM de muestra para la aplicación de Lambda del
tutorial (p. 281). Copie el texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha
creado anteriormente. Tenga en cuenta que los valores de los parámetros Handler y Runtime deben
coincidir con los que utilizó cuando creó la función en la sección anterior.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Example of processing messages on an SQS queue with Lambda
Resources:
MySQSQueueFunction:
Type: AWS::Serverless::Function
Properties:
Handler: [Link]
Runtime: nodejs12.x
Events:
MySQSEvent:
Type: SQS
Properties:
Queue: !GetAtt [Link]
BatchSize: 10
MySqsQueue:

287
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

Type: AWS::SQS::Queue

Para obtener más informaciónsobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementar aplicaciones sin servidor en la
Guía para desarrolladores deModelo de aplicación sin servidor de AWS.

288
 AWS Lambda Guía para desarrolladores

Creación de funciones de Lambda

con [Link]
Puede ejecutar Código JavaScript con [Link] en AWS Lambda. Lambda proporciona tiempos de
ejecución (p. 118) para [Link] que ejecutan código para procesar eventos. El código se ejecuta en un
entorno que incluye el AWS SDK for JavaScript, con credenciales de un rol de AWS Identity and Access
Management (IAM) administrado por usted.

Lambda admite los siguientes entornos de ejecución de [Link].

Tiempos de ejecución de [Link]

Nombre Identifier AWS SDK para Sistema operativo

JavaScript

[Link] 12 nodejs12.x 2.585.0 Amazon Linux 2

[Link] nodejs10.x 2.585.0 Amazon Linux 2

Las funciones de Lambda utilizan un rol de ejecución (p. 32) para obtener permiso para escribir registros
en Amazon CloudWatch Logs y para tener acceso a otros servicios y recursos. Si aún no tiene un rol de
ejecución para el desarrollo de funciones, cree uno.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Puede agregar permisos al rol más tarde o cambiarlo por otro rol específico para una sola función.

Para crear una función de [Link]

1. Abra la consola de Lambda.

2. Elija Create function (Crear función).
3. Configure los siguientes ajustes:

• Name (Nombre): my-function.

• Runtime (Tiempo de ejecución): [Link] 12.x.
• Role (Rol): Choose an existing role (Elija un rol existente).
• Existing role (Rol existente): lambda-role.

289
 AWS Lambda Guía para desarrolladores
Controlador

4. Elija Create function (Crear función).

5. Para configurar un evento de prueba, seleccione Test (Prueba).
6. Para Event name (Nombre de evento), escriba test.
7. Seleccione Create.
8. Para ejecutar la función, seleccione Test (Prueba).

La consola crea una función de Lambda con un único archivo de origen denominado [Link]. Puede
editar este archivo y agregar más archivos en el editor de código (p. 6) integrado. Para guardar los
cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note

La consola de Lambda utiliza AWS Cloud9 para proporcionar un entorno de desarrollo integrado
en el navegador. También puede utilizar AWS Cloud9 para desarrollar funciones Lambda en su
propio entorno. Para más información, consulte Trabajar con funciones de AWS Lambda en la
Guía del usuario de AWS Cloud9.

El archivo [Link] exporta una función denominada handler que toma un objeto de evento y un objeto
context. Esta es la función de controlador (p. 290) a la que llama Lambda cuando se invoca la función. El
tiempo de ejecución de la función de [Link] obtiene los eventos de invocación de Lambda y se los pasa
al controlador. En la configuración de función, el valor de controlador es [Link].

Cada vez que guarde el código de la función, la consola de Lambda crea un paquete de implementación,
que es un archivo ZIP que contiene el código de su función. A medida que avanza su función de desarrollo,
querrá almacenar su código de función en el control del código fuente, agregar bibliotecas y automatizar
las implementaciones. Comience creando un paquete de implementación (p. 292) y actualizando el
código en la línea de comandos.

El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de
invocación. El objeto context (p. 294) contiene información adicional acerca de la invocación, la función y
el entorno de ejecución. Más información disponible en las variables de entorno.

La función de Lambda incluye un grupo de registros de CloudWatch Logs. El tiempo de ejecución de la

función envía detalles sobre cada invocación a CloudWatch Logs. Retransmite cualquier registro que
genere la función (p. 295) durante la invocación. Si la función devuelve un error (p. 299), Lambda
formatea el error y se lo devuelve al invocador.

Temas
• Controlador de la función AWS Lambda en [Link] (p. 290)
• Paquete de implementación AWS Lambda en [Link] (p. 292)
• Objeto context AWS Lambda en [Link] (p. 294)
• Registro de funciones AWS Lambda en [Link] (p. 295)
• Errores de funciones AWS Lambda en [Link] (p. 299)
• Instrumentación del código [Link] en AWS Lambda (p. 300)

Controlador de la función AWS Lambda en [Link]

El controlador es el método de su función de Lambda que procesa eventos. Al invocar una función, el
tiempo de ejecución (p. 118) ejecuta el método del controlador. Si el controlador existe o devuelve una
respuesta, pasará a estar disponible para gestionar otro evento.

La siguiente función de ejemplo registra el contenido del objeto de evento y devuelve la ubicación de los
registros.

290
 AWS Lambda Guía para desarrolladores
Controladores asincrónicos

Example [Link]

[Link] = async function(event, context) {

[Link]("EVENT: \n" + [Link](event, null, 2))
return [Link]
}

Al configurar una función (p. 52), el valor del controlador es el nombre del archivo y el nombre de un
módulo del controlador exportado, separados por un punto. El valor predeterminado en la consola y para
ejemplos de esta guía es [Link]. Esto indica el módulo handler que [Link] exporta.

El tiempo de ejecución pasa tres argumentos al método del controlador. El primer argumento es el objeto
event, que contiene información del invoker. El invocador pasa esta información como una cadena con
formato JSON cuando llama a Invoke (p. 527) y el tiempo de ejecución la convierte en un objeto. Cuando
un servicio de AWS invoca su función, la estructura de eventos varía por servicio (p. 153).

El segundo argumento es el objeto context (p. 294), que incluye información sobre la invocación,
la función y el entorno de ejecución. En el ejemplo anterior, la función obtiene el nombre de flujo de
registro (p. 295) del objeto context y lo devuelve al invocador.

El tercer argumento, callback, es una función a la que puede llamar en los controladores no
asincrónicos (p. 292) para enviar una respuesta. La función de devolución de llamada toma dos
argumentos: un Error y una respuesta. Cuando lo llama, Lambda espera a que el bucle de evento esté
vacío y luego devuelve la respuesta o error al invocador. El objeto de respuesta debe ser compatible con
[Link].

En los controladores asincrónicos, debe devolver una respuesta, un error o una promesa al tiempo de
ejecución en lugar de usar callback.

Controladores asincrónicos
En las funciones asincrónicas, puede utilizar return y throw para enviar una respuesta o un error,
respectivamente. Las funciones deben usar la palabra clave async para utilizar estos métodos a fin de
devolver una respuesta o error.

Si su código realiza una tarea asíncrona, devuelva una promesa para asegurarse que termina de
ejecutarse. Al resolver o rechazar la promesa, Lambda envía la respuesta o error al invocador.

Example Archivo [Link]: solicitud HTTP con un controlador asincrónico y promesas

const https = require('https')

let url = "[Link]

[Link] = async function(event) {

const promise = new Promise(function(resolve, reject) {
[Link](url, (res) => {
resolve([Link])
}).on('error', (e) => {
reject(Error(e))
})
})
return promise
}

Para las bibliotecas que devuelven una promesa, puede devolver esa promesa directamente al tiempo de
ejecución.

Example Archivo [Link]: SDK de AWS con un controlador asincrónico y promesas

const AWS = require('aws-sdk')

291
 AWS Lambda Guía para desarrolladores
Controladores no asincrónicos

const s3 = new AWS.S3()

[Link] = async function(event) {

return [Link]().promise()
}

Controladores no asincrónicos
La siguiente función de ejemplo comprueba una URL y devuelve el código de estado al invocador.

Example Archivo [Link]: solicitud HTTP con devolución de llamada

const https = require('https')

let url = "[Link]

[Link] = function(event, context, callback) {

[Link](url, (res) => {
callback(null, [Link])
}).on('error', (e) => {
callback(Error(e))
})
}

En los controladores no asincrónicos, la ejecución de la función prosigue hasta que el bucle de eventos
está vacío o se agota el tiempo de espera de la función. La respuesta no se envía al invoker hasta que
todas las tareas de bucle de eventos hayan terminado. Si el tiempo de espera de la función se agota,
se devolverá un error en su lugar. Puede configurar el tiempo de ejecución para enviar la respuesta
inmediatamente estableciendo [Link] (p. 294) en false.

En el siguiente ejemplo, la respuesta de Amazon S3 se devolverá al invocador tan pronto como esté
disponible. El tiempo de espera que se ejecuta en el bucle de eventos se ha detenido y continuará
ejecutándose la próxima vez que se invoque la función.

Example Archivo [Link]: callbackWaitsForEmptyEventLoop

const AWS = require('aws-sdk')

const s3 = new AWS.S3()

[Link] = function(event, context, callback) {

[Link] = false
[Link](null, callback)
setTimeout(function () {
[Link]('Timeout complete.')
}, 5000)
}

Paquete de implementación AWS Lambda en

[Link]
Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función.
Debe crear un paquete de implementación si utiliza la API de Lambda para administrar funciones o si
necesita incluir bibliotecas y dependencias distintas del AWS SDK. Puede cargar el paquete directamente
en Lambda o utilizar un bucket de Amazon S3 y, a continuación, cargarlo en Lambda. Si el paquete de
implementación tiene más de 50 MB, debe usar Amazon S3.

292
 AWS Lambda Guía para desarrolladores
Actualización de una función sin dependencias

Si utiliza el editor de consola (p. 6) de Lambda para crear la función, la consola administra el paquete de
implementación. Puede utilizar este método siempre y cuando no tenga que añadir ninguna biblioteca.
También puede utilizarlo para actualizar una función que ya tenga bibliotecas en el paquete de
implementación, siempre y cuando el tamaño total no supere el 3 MB.
Note

Para que el tamaño del paquete de implementación sea reducido, empaquete las dependencias
de la función en capas. Las capas le permiten administrar las dependencias de forma
independiente, pueden utilizarlas varias funciones y pueden compartirse con otras cuentas. Para
obtener más información, consulte Capas de AWS Lambda (p. 74).

Secciones
• Actualización de una función sin dependencias (p. 293)
• Actualización de una función con dependencias adicionales (p. 293)

Actualización de una función sin dependencias

Para actualizar una función mediante la API de Lambda, utilice la operación
UpdateFunctionCode (p. 598). Cree un archivo que contenga el código de la función y cárguelo con la
AWS CLI.

Para actualizar una función de [Link] sin dependencias

1. Cree un archivo ZIP.

~/my-function$ zip [Link] [Link]

2. Utilice el comando update-function-code para cargar el paquete.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Actualización de una función con dependencias

adicionales
Si la función depende de bibliotecas distintas del SDK for JavaScript, instálelas en un directorio local
con NPM e inclúyalas en el paquete de implementación. También puede incluir el SDK for JavaScript
si necesita una versión más reciente que la incluida en el tiempo de ejecución (p. 289), o bien para
garantizar que la versión no cambie en el futuro.

293
 AWS Lambda Guía para desarrolladores
Contexto

Para actualizar una función de [Link] con dependencias

1. Instale bibliotecas en el directorio node_modules con el comando npm install.

~/my-function$ npm install aws-xray-sdk

De este modo se crea una estructura de carpetas similar a la siguiente.

~/my-function
### [Link]
### node_modules
### async
### async-listener
### atomic-batcher
### aws-sdk
### aws-xray-sdk
### aws-xray-sdk-core

2. Cree un archivo ZIP con el contenido de la carpeta del proyecto.

~/my-function$ zip -r [Link] .

3. Utilice el comando update-function-code para cargar el paquete.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Además del código y las bibliotecas, su paquete de implementación también puede incluir archivos
ejecutables y otros recursos. Para obtener más información, consulte los siguientes temas:

• Ejecución de ejecutables en AWS Lambda

• Uso de paquetes y módulos nodejs en AWS Lambda

Objeto context AWS Lambda en [Link]

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 290). Este objeto
proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el
entorno de ejecución.

Métodos de context

• getRemainingTimeInMillis(): Devuelve el número de milisegundos que faltan antes de que se

agote el tiempo de espera.

294
 AWS Lambda Guía para desarrolladores
Registro

Propiedades de context

• functionName: El nombre de la función de Lambda.

• functionVersion: La versión (p. 68) de la función.
• invokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
Indica si el invocador ha especificado un alias o un número de versión.
• memoryLimitInMB: La cantidad de memoria que se asigna para la función.
• awsRequestId: El identificador de la solicitud de invocación.
• logGroupName: El grupo de registros de la función.
• logStreamName: El flujo de registro para la instancia de la función.
• identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• cognitoIdentityId: La identidad de Amazon Cognito autenticada.
• cognitoIdentityPoolId: El grupo de identidades de Amazon Cognito que ha autorizado la
invocación.
• clientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
aplicación del cliente.
• client.installation_id
• client.app_title
• client.app_version_name
• client.app_version_code
• client.app_package_name
• env.platform_version
• [Link]
• [Link]
• [Link]
• [Link]
• Custom: valores personalizados que establece la aplicación móvil.
• callbackWaitsForEmptyEventLoop: configúrelo en false para enviar la respuesta de forma
inmediata cuando se ejecuta la devolución de llamada (p. 292), en lugar de esperar a que el bucle de
eventos de [Link] esté vacío. Si esto es false, los eventos pendientes siguen ejecutándose durante el
siguiente periodo de invocación.

La siguiente función de ejemplo registra información de contexto y devuelve la ubicación de los registros.

Example Archivo [Link]

[Link] = async function(event, context) {

[Link]('Remaining time: ', [Link]())
[Link]('Function name: ', [Link])
return [Link]
}

Registro de funciones AWS Lambda en [Link]

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

295
 AWS Lambda Guía para desarrolladores
Registro

Para generar registros desde el código de las funciones, puede utilizar los métodos del objeto de la
consola o cualquier biblioteca de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se
registran los valores de las variables de entorno y el objeto de evento.

Example Archivo [Link]: registro

[Link] = async function(event, context) {

[Link]("ENVIRONMENT VARIABLES\n" + [Link]([Link], null, 2))
[Link]("EVENT\n" + [Link](event, null, 2))
[Link]("Event not processed.")
return [Link]
}

Example Formato de registro

START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST

2019-06-07T19:11:20.562Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO ENVIRONMENT VARIABLES
{
"AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
"AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
"AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
"AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
"AWS_LAMBDA_FUNCTION_NAME": "my-function",
"PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
"NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/
node_modules",
...
}
2019-06-07T19:11:20.563Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO EVENT
{
"key": "value"
}
2019-06-07T19:11:20.564Z c793869b-ee49-115b-a5b6-4fd21e8dedac WARN Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Duration: 128.83 ms Billed Duration:
200 ms Memory Size: 128 MB Max Memory Used: 74 MB Init Duration: 166.62 ms XRAY TraceId:
1-5d9d007f-0a8c7fd02xmpl480aed55ef0 SegmentId: 3d752xmpl1bbe37e Sampled: true

El tiempo de ejecución de [Link] registra las líneas START, END y REPORT de cada invocación. Se agrega
una marca de tiempo, un ID de solicitud y el nivel de registro en cada entrada registrada por la función. La
línea del informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

296
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 297)
• Mediante la AWS CLI (p. 297)
• Eliminación de registros (p. 299)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

297
 AWS Lambda Guía para desarrolladores
Mediante la AWS CLI

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

298
 AWS Lambda Guía para desarrolladores
Eliminación de registros

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

Errores de funciones AWS Lambda en [Link]

Cuando el código devuelve un error, Lambda genera una representación JSON de este. Este documento
de error aparece en el registro de invocación y, en el caso de las invocaciones síncronas, en la salida.

Example Archivo [Link]: error de referencia

[Link] = async function() {

return x + 10
}

Este código da como resultado un error de referencia. Lambda detecta el error y genera un documento
JSON con campos para el mensaje de error, el tipo y el seguimiento de la pila.

{
"errorType": "ReferenceError",
"errorMessage": "x is not defined",
"trace": [
"ReferenceError: x is not defined",
" at [Link] (/var/task/[Link]:3)",
" at [Link] (/var/runtime/[Link]:25)",
" at process._tickCallback (internal/process/next_tick.js:68:7)"
]
}

Cuando se invoca la función desde la línea de comandos, la AWS CLI divide la respuesta en dos
documentos. Para indicar que se ha producido un error en la función, la respuesta que se muestra en el
terminal incluye un campo FunctionError. La respuesta o el error que devuelve la función se escribe en
el archivo de salida.

$ aws lambda invoke --function-name my-function [Link]

{
"StatusCode": 200,
"FunctionError": "Unhandled",
"ExecutedVersion": "$LATEST"
}

Examine el archivo de salida para ver el documento de error.

$ cat [Link]
{"errorType":"ReferenceError","errorMessage":"x is not defined","trace":["ReferenceError:
x is not defined"," at [Link] (/var/task/[Link]:3)"," at
[Link] (/var/runtime/[Link]:25)"," at process._tickCallback (internal/
process/next_tick.js:68:7)"]}

Note

El código de estado 200 (correcto) de la respuesta de Lambda indica que no hubo ningún error
en la solicitud que envió a Lambda. Para ver los problemas que generan un código de estado de
error, consulte Errors (p. 529).

299
 AWS Lambda Guía para desarrolladores
Rastreo

Lambda también registra hasta 256 KB del objeto de error en los registros de la función. Para ver los
registros cuando realice la invocación de la función desde la línea de comandos, utilice la opción --log-
type y descodifique la cadena base64 de la respuesta.

$ aws lambda invoke --function-name my-function [Link] --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 Version: $LATEST
2019-06-05T22:11:27.082Z 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 ERROR Invoke
Error {"errorType":"ReferenceError","errorMessage":"x is not defined","stack":
["ReferenceError: x is not defined"," at [Link] (/var/task/
[Link]:3)"," at [Link] (/var/runtime/[Link]:25)"," at
process._tickCallback (internal/process/next_tick.js:68:7)"]}
END RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64
REPORT RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 Duration: 76.85 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 74 MB

Para obtener más información acerca de los registros, consulte Registro de funciones AWS Lambda en
[Link] (p. 295).

En función del origen de eventos, AWS Lambda podría volver a intentar la ejecución de la función de
Lambda que ha generado un error. Por ejemplo, si Kinesis es el origen de eventos, AWS Lambda reintenta
la invocación que produce errores hasta que la función de Lambda se ejecute correctamente o hasta que
los registros del flujo caduquen. Para obtener más información acerca de los reintentos, consulte Control
de errores y reintentos automáticos en AWS Lambda (p. 107).

Instrumentación del código [Link] en AWS

Lambda
En [Link], puede hacer que Lambda emita subsegmentos a X-Ray para mostrar información acerca de
las llamadas posteriores a otros servicios de AWS realizadas por la función. Para ello, primero debe incluir
el SDK de AWS X-Ray para [Link] en el paquete de implementación. Además, encapsule la instrucción
require del SDK de AWS como se indica a continuación.

const AWSXRay = require('aws-xray-sdk-core')

const AWS = [Link](require('aws-sdk'))

A continuación, utilice la variable de AWS definida en el ejemplo anterior para inicializar cualquier cliente
del servicio que desee rastrear con X-Ray, por ejemplo:

const s3 = new AWS.S3()

Después de seguir estos pasos, cualquier llamada realizada desde la función utilizando s3Client da
como resultado un subsegmento de X-Ray que representa esa llamada. Por ejemplo, puede ejecutar la
función de [Link] siguiente para ver el rastro en X-Ray.

Example [Link]

const AWSXRay = require('aws-xray-sdk-core')

const AWS = [Link](require('aws-sdk'))
const s3 = new AWS.S3()

[Link] = async function(event) {

return [Link]().promise()
}

300
 AWS Lambda Guía para desarrolladores
Rastreo

A continuación se muestra cómo se visualiza un rastro emitido por el código anterior.

301
 AWS Lambda Guía para desarrolladores

Creación de funciones de Lambda

con Python
Puede ejecutar Python code en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 118) para
Python que ejecutan código para procesar eventos. El código se ejecuta en un entorno que incluye el
SDK para Python (Boto 3), con credenciales de un rol de AWS Identity and Access Management (IAM)
administrado por usted.

Lambda admite los siguientes entornos de ejecución de Python.

Tiempos de ejecución de Python

Nombre Identifier AWS SDK para Python Sistema operativo

Python 3.8 python3.8 boto3-1.10.34 Amazon Linux 2

botocore-1.13.34

Python 3.7 python3.7 boto3-1.10.34 Amazon Linux

botocore-1.13.34

Python 3.6 python3.6 boto3-1.10.34 Amazon Linux

botocore-1.13.34

Python 2.7 python2.7 boto3-1.10.34 Amazon Linux

botocore-1.13.34

Las funciones de Lambda utilizan un rol de ejecución (p. 32) para obtener permiso para escribir registros
en Amazon CloudWatch Logs y para tener acceso a otros servicios y recursos. Si aún no tiene un rol de
ejecución para el desarrollo de funciones, cree uno.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Puede agregar permisos al rol más tarde o cambiarlo por otro rol específico para una sola función.

Para crear una función de Python

1. Abra la consola de Lambda.

302
 AWS Lambda Guía para desarrolladores

2. Elija Create function (Crear función).

3. Configure los siguientes ajustes:

• Name (Nombre): my-function.

• Runtime (Tiempo de ejecución): Python 3.8.
• Role (Rol): Choose an existing role (Elija un rol existente).
• Existing role (Rol existente): lambda-role.
4. Elija Create function (Crear función).
5. Para configurar un evento de prueba, seleccione Test (Prueba).
6. Para Event name (Nombre de evento), escriba test.
7. Seleccione Create.
8. Para ejecutar la función, seleccione Test (Prueba).

La consola crea una función de Lambda con un único archivo de origen denominado lambda_function.
Puede editar este archivo y agregar más archivos en el editor de código (p. 6) integrado. Para guardar los
cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note

La consola de Lambda utiliza AWS Cloud9 para proporcionar un entorno de desarrollo integrado
en el navegador. También puede utilizar AWS Cloud9 para desarrollar funciones Lambda en su
propio entorno. Para más información, consulte Trabajar con funciones de AWS Lambda en la
Guía del usuario de AWS Cloud9.

El archivo lambda_function exporta una función denominada lambda_handler que toma un objeto
de evento y un objeto context. Esta es la función de controlador (p. 304) a la que llama Lambda cuando
se invoca la función. El tiempo de ejecución de la función de Python obtiene los eventos de invocación
de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador es
lambda_function.lambda_handler.

Cada vez que guarde el código de la función, la consola de Lambda crea un paquete de implementación,
que es un archivo ZIP que contiene el código de su función. A medida que avanza su función de desarrollo,
querrá almacenar su código de función en el control del código fuente, agregar bibliotecas y automatizar
las implementaciones. Comience creando un paquete de implementación (p. 304) y actualizando el
código en la línea de comandos.

El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de
invocación. El objeto context (p. 308) contiene información adicional acerca de la invocación, la función y
el entorno de ejecución. Más información disponible en las variables de entorno.

La función de Lambda incluye un grupo de registros de CloudWatch Logs. El tiempo de ejecución de la

función envía detalles sobre cada invocación a CloudWatch Logs. Retransmite cualquier registro que
genere la función (p. 309) durante la invocación. Si la función devuelve un error (p. 313), Lambda
formatea el error y se lo devuelve al invocador.

Temas
• Controlador de funciones AWS Lambda en Python (p. 304)
• Paquete de implementación de AWS Lambda en Python (p. 304)
• Objeto context AWS Lambda en Python (p. 308)
• Registro de funciones AWS Lambda en Python (p. 309)
• Errores de funciones AWS Lambda en Python (p. 313)
• Instrumentación del código Python en AWS Lambda (p. 314)

303
 AWS Lambda Guía para desarrolladores
Controlador

Controlador de funciones AWS Lambda en Python

En el momento de crear una función de Lambda, debe especificar un controlador, que es una función en el
código, que AWS Lambda puede invocar cuando el servicio ejecuta el código. Utilice la siguiente estructura
de sintaxis general al crear una función de controlador en Python.

def handler_name(event, context):

...
return some_value

En la sintaxis, tenga en cuenta lo siguiente:

• event: AWS Lambda utiliza este parámetro para pasar datos de eventos al controlador. Este parámetro
suele ser del tipo dict de Python. También puede ser del tipo list, str, int, float, o NoneType.

Cuando se invoca una función, se determina el contenido y la estructura del evento. Cuando un servicio
de AWS invoca su función, la estructura del evento varía en función del servicio. Para obtener más
información, consulte Uso de AWS Lambda con otros servicios (p. 153).
• context: AWS Lambda utiliza este parámetro para proporcionar información sobre el tiempo de
ejecución al controlador. Para obtener más información, consulte Objeto context AWS Lambda en
Python (p. 308).
• Si lo desea, el controlador puede devolver un valor. Lo que sucede con el valor devuelto depende del
tipo de invocación que se utilice al invocar la función de Lambda:
• Si se utiliza el tipo de invocación RequestResponse (ejecución síncrona), AWS Lambda devuelve
el resultado de la llamada a la función de Python al cliente que invoca la función de Lambda (en la
respuesta HTTP a la solicitud de invocación, serializada en JSON). Por ejemplo, la consola de AWS
Lambda utiliza el tipo de invocación RequestResponse, por lo que al invocar la función utilizando la
consola, esta mostrará el valor devuelto.
• Si el controlador devuelve objetos que no se pueden serializar con [Link], el tiempo de
ejecución devuelve un error.
• Si el controlador devuelve None, al igual que hacen las funciones de Python sin una instrucción
return, el runtime devuelve null.
• Si se utiliza el tipo de invocación Event (ejecución asíncrona), el valor se descarta.

Por ejemplo, fíjese en el siguiente código de ejemplo de Python.

def my_handler(event, context):

message = 'Hello {} {}!'.format(event['first_name'],
event['last_name'])
return {
'message' : message
}

Este ejemplo tiene una función denominada my_handler. La función devuelve un mensaje que contiene
los datos del evento que recibió como entrada.

Paquete de implementación de AWS Lambda en

Python
Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función.
Debe crear un paquete de implementación si utiliza la API de Lambda para administrar funciones o si

304
 AWS Lambda Guía para desarrolladores
Requisitos previos

necesita incluir bibliotecas y dependencias distintas del AWS SDK. Puede cargar el paquete directamente
en Lambda o utilizar un bucket de Amazon S3 y, a continuación, cargarlo en Lambda. Si el paquete de
implementación tiene más de 50 MB, debe usar Amazon S3.

Si utiliza el editor de consola (p. 6) de Lambda para crear la función, la consola administra el paquete de
implementación. Puede utilizar este método siempre y cuando no tenga que añadir ninguna biblioteca.
También puede utilizarlo para actualizar una función que ya tenga bibliotecas en el paquete de
implementación, siempre y cuando el tamaño total no supere el 3 MB.
Note

Puede utilizar el comando build de la CLI de AWS SAM para crear un paquete de
implementación para el código y las dependencias de la función de Python. La CLI de AWS SAM
también proporciona una opción para crear el paquete de implementación dentro de una imagen
de Docker que es compatible con el entorno de ejecución de Lambda. Para obtener instrucciones,
consulte el tema relacionado con la creación de aplicaciones con dependencias en la guía para
desarrolladores de AWS SAM.

Secciones
• Requisitos previos (p. 305)
• Actualización de una función sin dependencias (p. 305)
• Actualización de una función con dependencias adicionales (p. 306)
• Con un entorno virtual (p. 307)

Requisitos previos
En estas instrucciones se da por hecho que ya tiene una función. Si no ha creado aún una función,
consulte Creación de funciones de Lambda con Python (p. 302).

Para seguir los procedimientos de esta guía, necesitará un shell o un terminal de línea de comando donde
pueda ejecutar los comandos. Los comandos aparecen en listas y van precedidos del símbolo del sistema
($) y del nombre del directorio actual, si es aplicable:

~/lambda-project$ this is a command

this is output

Para los comandos largos, se utiliza un carácter de escape (\) para dividir un comando en varias líneas.

En Linux y macOS, use su administrador de shell y paquetes preferido. En Windows 10, puede instalar
Windows Subsystem para Linux para obtener una versión de Ubuntu y Bash integrada con Windows.

Actualización de una función sin dependencias

Para crear o actualizar una función con la API de Lambda, cree un archivo que contenga el código de la
función y cárguelo con la AWS CLI.

Para actualizar una función de Python sin dependencias

1. Cree un archivo ZIP.

~/my-function$ zip [Link] lambda_function.py

adding: lambda_function.py (deflated 17%)

2. Utilice el comando update-function-code para cargar el paquete.

305
 AWS Lambda Guía para desarrolladores
Actualización de una función con dependencias adicionales

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "python3.8",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "lambda_function.lambda_handler",
"CodeSize": 815,
"CodeSha256": "GcZ05oeHoJi61VpQj7vCLPs8DwCXmX5sE/fE2IHsizc=",
"Version": "$LATEST",
"RevisionId": "d1e983e3-ca8e-434b-8dc1-7add83d72ebd",
...
}

Actualización de una función con dependencias

adicionales
Si la función depende de bibliotecas distintas del SDK para Python (Boto 3), instálelas en un directorio local
con pip e inclúyalas en el paquete de implementación.
Note
Para las bibliotecas que utilizan módulos de extensión escritos en C o C++, cree el paquete de
implementación en un entorno de Amazon Linux. Puede utilizar el comando de compilación de la
CLI de SAM, que utiliza Docker, o crear el paquete de implementación en Amazon EC2 o AWS
CodeBuild.

En el ejemplo siguiente se muestra cómo crear un paquete de implementación que incluya una biblioteca
de gráficos común denominada Pillow.

Para actualizar una función de Python con dependencias

1. Instale las bibliotecas en un nuevo directorio package local del proyecto con la opción --target de
pip.

~/my-function$ pip install --target ./package Pillow

Collecting Pillow
Using cached [Link]
packages/62/8c/230204b8e968f6db00c765624f51cfd1ecb6aea57b25ba00b240ee3fb0bd/
Pillow-5.3.0-cp37-cp37m-manylinux1_x86_64.whl
Installing collected packages: Pillow
Successfully installed Pillow-5.3.0

Note
Para que --target funcione en sistemas basados en Debian como Ubuntu, es posible que
también tenga que transferir la marca --system para evitar errores distutils.
2. Cree un archivo ZIP de las dependencias.

~/my-function$ cd package
~/my-function/package$ zip -r9 ${OLDPWD}/[Link] .
adding: PIL/ (stored 0%)
adding: PIL/.libs/ (stored 0%)
adding: PIL/.libs/[Link].6.16.1 (deflated 65%)
adding: PIL/.libs/[Link].9.3.0 (deflated 72%)
adding: PIL/.libs/[Link].2.0.8 (deflated 67%)

306
 AWS Lambda Guía para desarrolladores
Con un entorno virtual

...

3. Añada el código de la función al archivo comprimido.

~/my-function/package$ cd $OLDPWD
~/my-function$ zip -g [Link] lambda_function.py
adding: lambda_function.py (deflated 56%)

4. Actualice el código de la función.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "python3.8",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "lambda_function.lambda_handler",
"CodeSize": 2269409,
"CodeSha256": "GcZ05oeHoJi61VpQj7vCLPs8DwCXmX5sE/fE2IHsizc=",
"Version": "$LATEST",
"RevisionId": "a9c05ffd-8ad6-4d22-b6cd-d34a00c1702c",
...
}

Con un entorno virtual

En algunos casos, puede que tenga que utilizar un entorno virtual para instalar las dependencias de la
función. Esto puede ocurrir si la función o sus dependencias dependen de las bibliotecas nativas o si utiliza
Homebrew para instalar Python.

Para actualizar una función de Python con un entorno virtual

1. Cree un entorno virtual.

~/my-function$ virtualenv v-env

Using base prefix '~/.local/python-3.7.0'
New python executable in v-env/bin/python3.8
Also creating executable in v-env/bin/python
Installing setuptools, pip, wheel...
done.

Note

En Python 3.3 y posteriores, puede utilizar el módulo venv integrado para crear un entorno
virtual, en lugar de instalar virtualenv.

~/my-function$ python3 -m venv v-env

2. Active el entorno.

~/my-function$ source v-env/bin/activate

(v-env) ~/my-function$

3. Instale las bibliotecas con pip.

(v-env) ~/my-function$ pip install Pillow

307
 AWS Lambda Guía para desarrolladores
Contexto

Collecting Pillow
Using cached [Link]
packages/62/8c/230204b8e968f6db00c765624f51cfd1ecb6aea57b25ba00b240ee3fb0bd/
Pillow-5.3.0-cp37-cp37m-manylinux1_x86_64.whl
Installing collected packages: Pillow
Successfully installed Pillow-5.3.0

4. Desactive el entorno virtual.

(v-env) ~/my-function$ deactivate

5. Cree un archivo ZIP con el contenido de la biblioteca.

~/my-function$ cd v-env/lib/python3.8/site-packages
~/my-function/v-env/lib/python3.8/site-packages$ zip -r9 ${OLDPWD}/[Link] .
adding: easy_install.py (deflated 17%)
adding: PIL/ (stored 0%)
adding: PIL/.libs/ (stored 0%)
adding: PIL/.libs/[Link].6.16.1 (deflated 65%)
adding: PIL/.libs/[Link].9.3.0 (deflated 72%)
...

En función de la biblioteca, las dependencias pueden aparecer en site-packages o en dist-

packages, y la primera carpeta del entorno virtual puede ser lib o lib64. Puede utilizar el comando
pip show para localizar un paquete específico.
6. Añada el código de la función al archivo comprimido.

~/my-function/v-env/lib/python3.8/site-packages$ cd $OLDPWD
~/my-function$ zip -g [Link] lambda_function.py
adding: lambda_function.py (deflated 56%)

7. Actualice el código de la función.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "python3.8",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "lambda_function.lambda_handler",
"CodeSize": 5912988,
"CodeSha256": "A2P0NUWq1J+LtSbkuP8tm9uNYqs1TAa3M76ptmZCw5g=",
"Version": "$LATEST",
"RevisionId": "5afdc7dc-2fcb-4ca8-8f24-947939ca707f",
...
}

Objeto context AWS Lambda en Python

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 304). Este objeto
proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el
entorno de ejecución.

Métodos de context

• get_remaining_time_in_millis – Devuelve el número de milisegundos que faltan antes de que se

agote el tiempo de espera.

308
 AWS Lambda Guía para desarrolladores
Registro

Propiedades de context

• function_name – El nombre de la función de Lambda.

• function_version – La versión (p. 68) de la función.
• invoked_function_arn – El nombre de recurso de Amazon (ARN) que se utiliza para invocar la
función. Indica si el invocador ha especificado un alias o un número de versión.
• memory_limit_in_mb – La cantidad de memoria que se asigna para la función.
• aws_request_id – El identificador de la solicitud de invocación.
• log_group_name – El grupo de registros de la función.
• log_stream_name: El flujo de registro para la instancia de la función.
• identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• cognito_identity_id: La identidad de Amazon Cognito autenticada.
• cognito_identity_pool_id: El grupo de identidades de Amazon Cognito que ha autorizado la
invocación.
• client_context: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de
la aplicación del cliente.
• client.installation_id
• client.app_title
• client.app_version_name
• client.app_version_code
• client.app_package_name
• custom: un elemento dict de valores personalizados establecidos por la aplicación cliente para
móviles.
• env: un elemento dict de información de entorno proporcionado por el AWS SDK.

En el siguiente ejemplo se muestra una función de controlador que registra información de context.

Example [Link]

import time
def get_my_log_stream(event, context):
print("Log stream name:", context.log_stream_name)
print("Log group name:", context.log_group_name)
print("Request ID:",context.aws_request_id)
print("Mem. limits(MB):", context.memory_limit_in_mb)
# Code will execute quickly, so we add a 1 second intentional delay so you can see that
in time remaining value.
[Link](1)
print("Time remaining (MS):", context.get_remaining_time_in_millis())

Además de las opciones que se enumeran anteriormente, también puede utilizar el SDK de AWS X-Ray
para Instrumentación del código Python en AWS Lambda (p. 314) a fin de identificar las rutas de código
críticas, rastrear su desempeño y capturar los datos para su análisis.

Registro de funciones AWS Lambda en Python

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

309
 AWS Lambda Guía para desarrolladores
Registro

Para generar registros desde el código de su función, puede utilizar el método print o cualquier biblioteca
de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se registran los valores de las
variables de entorno y el objeto de evento.

Example lambda_function.py

import json
import os

def lambda_handler(event, context):

print('## ENVIRONMENT VARIABLES')
print([Link])
print('## EVENT')
print(event)

Example Formato de registro

START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST

## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function',
'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c',
'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled:
true

El tiempo de ejecución de Python registra las líneas START, END y REPORT de cada invocación. La línea
del informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 311)
• Mediante la AWS CLI (p. 311)
• Eliminación de registros (p. 312)

310
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

• Biblioteca de registro (p. 313)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

311
 AWS Lambda Guía para desarrolladores
Eliminación de registros

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

312
 AWS Lambda Guía para desarrolladores
Biblioteca de registro

Biblioteca de registro
Para obtener registros más detallados, utilice la biblioteca de registro.

import json
import os
import logging
logger = [Link]()
[Link]([Link])

def lambda_handler(event, context):

[Link]('## ENVIRONMENT VARIABLES')
[Link]([Link])
[Link]('## EVENT')
[Link](event)

La salida de logger incluye el nivel de registro, la marca de tiempo y el ID de la solicitud.

START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST

[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT
VARIABLES

[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125

environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function',
'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d',
'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})

[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT

[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key':

'value'}

END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125

REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 113.51 ms
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled:
true

Errores de funciones AWS Lambda en Python

Cuando el código devuelve un error, Lambda genera una representación JSON de este. Este documento
de error aparece en el registro de invocación y, en el caso de las invocaciones síncronas, en la salida.

Example Archivo lambda_function.py: Excepción

def lambda_handler(event, context):

return x + 10

Este código da como resultado un error de nombre. Lambda detecta el error y genera un documento JSON
con campos para el mensaje de error, el tipo y el seguimiento de la pila.

{
"errorMessage": "name 'x' is not defined",
"errorType": "NameError",
"stackTrace": [

313
 AWS Lambda Guía para desarrolladores
Rastreo

" File \"/var/task/error_function.py\", line 2, in lambda_handler\n return x +

10\n"
]
}

Cuando se invoca la función desde la línea de comandos, la AWS CLI divide la respuesta en dos
documentos. Para indicar que se ha producido un error en la función, la respuesta que se muestra en el
terminal incluye un campo FunctionError. La respuesta o el error que devuelve la función se escribe en
el archivo de salida.

$ aws lambda invoke --function-name my-function [Link]

{
"StatusCode": 200,
"FunctionError": "Unhandled",
"ExecutedVersion": "$LATEST"
}

Examine el archivo de salida para ver el documento de error.

$ cat [Link]
{"errorMessage": "name 'x' is not defined", "errorType": "NameError", "stackTrace": ["
File \"/var/task/error_function.py\", line 2, in lambda_handler\n return x + 10\n"]}

Note

El código de estado 200 (correcto) de la respuesta de Lambda indica que no hubo ningún error
en la solicitud que envió a Lambda. Para ver los problemas que generan un código de estado de
error, consulte Errors (p. 529).

Lambda también registra hasta 256 KB del objeto de error en los registros de la función. Para ver los
registros cuando realice la invocación de la función desde la línea de comandos, utilice la opción --log-
type y descodifique la cadena base64 de la respuesta.

$ aws lambda invoke --function-name my-function [Link] --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9 Version: $LATEST
return x + 10/lambda_function.py", line 2, in lambda_handler
END RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9
REPORT RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9 Duration: 12.33 ms Billed Duration:
100 ms Memory Size: 128 MB Max Memory Used: 56 MB

Para obtener más información acerca de los registros, consulte Registro de funciones AWS Lambda en
Python (p. 309).

Instrumentación del código Python en AWS

Lambda
En Python, puede hacer que Lambda emita subsegmentos a X-Ray para mostrar información acerca de las
llamadas posteriores a otros servicios de AWS realizadas por la función. Para ello, primero debe incluir el
AWS X-Ray SDK for Python en el paquete de implementación. Además, puede aplicar parches a boto3 (o
botocore si está usando sesiones), de modo que cualquier cliente que cree para obtener acceso a otros
servicios de AWS será rastreado automáticamente por X-Ray.

import boto3

314
 AWS Lambda Guía para desarrolladores
Rastreo

from aws_xray_sdk.core import xray_recorder

from aws_xray_sdk.core import patch

patch(['boto3'])

Una vez que haya aplicado el parche al módulo que está utilizando para crear clientes, puede usarlo para
crear clientes rastreados, como Amazon S3 en el ejemplo siguiente:

s3_client = [Link]('s3')

El SDK de X-Ray para Python crea un subsegmento para la llamada y registra la información de la
solicitud y la respuesta. Puede utilizar aws_xray_sdk_sdk.core.xray_recorder para crear
subsegmentos automáticamente, modificando las funciones de Lambda, o manualmente, llamando a
xray_recorder.begin_subsegment() y xray_recorder.end_subsegment() dentro de la función,
tal como se muestra en la siguiente función de Lambda.

import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch

patch(['boto3'])

s3_client = [Link]('s3')

def lambda_handler(event, context):

bucket_name = event['bucket_name']
bucket_key = event['bucket_key']
body = event['body']

put_object_into_s3(bucket_name, bucket_key, body)

get_object_from_s3(bucket_name, bucket_key)

# Define subsegments manually

def put_object_into_s3(bucket_name, bucket_key, body):
try:
xray_recorder.begin_subsegment('put_object')
response = s3_client.put_object(Bucket=bucket_name, Key=bucket_key, Body=body)
status_code = response['ResponseMetadata']['HTTPStatusCode']
xray_recorder.current_subsegment().put_annotation('put_response', status_code)
finally:
xray_recorder.end_subsegment()

# Use decorators to automatically set the subsegments

@xray_recorder.capture('get_object')
def get_object_from_s3(bucket_name, bucket_key):
response = s3_client.get_object(Bucket=bucket_name, Key=bucket_key)
status_code = response['ResponseMetadata']['HTTPStatusCode']
xray_recorder.current_subsegment().put_annotation('get_response', status_code)

Note

El SDK de X-Ray para Python le permite aplicar parches a los siguientes módulos:

• botocore
• boto3
• requests
• sqlite3
• mysql

315
 AWS Lambda Guía para desarrolladores
Rastreo

Puede utilizar patch_all() para aplicar parches a todos a la vez.

A continuación se muestra cómo se visualiza un rastro emitido por el código anterior (invocación síncrona):

316
 AWS Lambda Guía para desarrolladores

Creación de funciones Lambda con

Ruby
Puede ejecutar Ruby code en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 118) para Ruby
que ejecutan código para procesar eventos. El código se ejecuta en un entorno que incluye el AWS SDK
parar Ruby, con credenciales de un rol de AWS Identity and Access Management (IAM) administrado por
usted.

Lambda admite los siguientes entornos de ejecución de Ruby.

Runtimes de Ruby

Nombre Identificador AWS SDK para Ruby Sistema operativo

Ruby 2.7 ruby2.7 3.0.1 Amazon Linux 2

Ruby 2.5 ruby2.5 3.0.1 Amazon Linux

Las funciones de Lambda utilizan un rol de ejecución (p. 32) para obtener permiso para escribir registros
en Amazon CloudWatch Logs y para tener acceso a otros servicios y recursos. Si aún no tiene un rol de
ejecución para el desarrollo de funciones, cree uno.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Puede agregar permisos al rol más tarde o cambiarlo por otro rol específico para una sola función.

Para crear una función de Ruby

1. Abra la consola de Lambda.

2. Elija Create function (Crear función).
3. Configure los siguientes ajustes:

• Name (Nombre): my-function.

• Runtime (Tiempo de ejecución): Ruby 2.7.
• Role (Rol): Choose an existing role (Elija un rol existente).
• Existing role (Rol existente): lambda-role.
4. Elija Create function (Crear función).

317
 AWS Lambda Guía para desarrolladores
Controlador

5. Para configurar un evento de prueba, seleccione Test (Prueba).

6. Para Event name (Nombre de evento), escriba test.
7. Seleccione Create.
8. Para ejecutar la función, seleccione Test (Prueba).

La consola crea una función de Lambda con un único archivo de origen denominado
lambda_function.rb. Puede editar este archivo y agregar más archivos en el editor de código (p. 6)
integrado. Para guardar los cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note

La consola de Lambda utiliza AWS Cloud9 para proporcionar un entorno de desarrollo integrado
en el navegador. También puede utilizar AWS Cloud9 para desarrollar funciones Lambda en su
propio entorno. Para más información, consulte Trabajar con funciones de AWS Lambda en la
Guía del usuario de AWS Cloud9.

El archivo lambda_function.rb exporta una función denominada lambda_handler que toma un

objeto de evento y un objeto context. Esta es la función de controlador (p. 318) a la que llama Lambda
cuando se invoca la función. El tiempo de ejecución de la función de Ruby obtiene los eventos de
invocación de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador
es lambda_function.lambda_handler.

Cada vez que guarde el código de la función, la consola de Lambda crea un paquete de implementación,
que es un archivo ZIP que contiene el código de su función. A medida que avanza su función de desarrollo,
querrá almacenar su código de función en el control del código fuente, agregar bibliotecas y automatizar
las implementaciones. Comience creando un paquete de implementación (p. 319) y actualizando el
código en la línea de comandos.

El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de
invocación. El objeto context (p. 321) contiene información adicional acerca de la invocación, la función y
el entorno de ejecución. Más información disponible en las variables de entorno.

La función de Lambda incluye un grupo de registros de CloudWatch Logs. El tiempo de ejecución de la

función envía detalles sobre cada invocación a CloudWatch Logs. Retransmite cualquier registro que
genere la función (p. 322) durante la invocación. Si la función devuelve un error (p. 326), Lambda
formatea el error y se lo devuelve al invocador.

Temas
• Controlador de funciones de AWS Lambda en Ruby (p. 318)
• Paquete de implementación de AWS Lambda en Ruby (p. 319)
• Objeto context de AWS Lambda en Ruby (p. 321)
• Registro de funciones de AWS Lambda en Ruby (p. 322)
• Errores de funciones de AWS Lambda en Ruby (p. 326)

Controlador de funciones de AWS Lambda en Ruby

El controlador de funciones de Lambda es el método al que llama Lambda cuando se invoca la función.
En el siguiente ejemplo, el archivo [Link] define un método de controlador llamado handler. La
función de controlador tiene dos objetos como entrada y devuelve un documento JSON.

Example [Link]

require 'json'

318
 AWS Lambda Guía para desarrolladores
Paquete de implementación

def handler(event:, context:)

{ event: [Link](event), context: [Link]([Link]) }
end

En su configuración de la función, el valor handler indica a Lambda dónde encontrar el controlador.

Para el ejemplo anterior, el valor correcto para este valor es [Link]. Incluye dos nombres
separados por un punto: el nombre del archivo y el nombre del método del controlador.

También puede definir su método de controlador en una clase. En el siguiente ejemplo se define
un método de controlador llamado process en una clase llamada Handler en un módulo llamado
LambdaFunctions.

Example [Link]

module LambdaFunctions
class Handler
def [Link](event:,context:)
"Hello!"
end
end
end

En este caso, el valor del controlador es [Link]::[Link].

Los dos objetos que el controlador acepta son el evento de invocación y el contexto. El evento es un
objeto Ruby que contiene la carga que proporciona el invocador. Si la carga es un documento JSON, el
objeto de evento es un hash de Ruby. De lo contrario, es una cadena. Este objeto de contexto (p. 321)
tiene métodos y propiedades que facilitan información acerca de la invocación, la función y el entorno de
ejecución.

El controlador de la función se ejecuta cada vez que se invoca la función de Lambda. El código estático
fuera del controlador se ejecuta una vez por instancia de la función. Si su controlador utiliza recursos como
clientes de SDK y conexiones de bases de datos, puede crearlos fuera del método de controlador para
volver a utilizarlos en varias invocaciones.

Cada instancia de la función permite procesar varios eventos de invocación, pero solo procesa un evento
cada vez. El número de instancias que procesan un evento en un momento dado es la simultaneidad de la
función. Para obtener más información acerca del contexto de ejecución de Lambda, consulte Contexto de
ejecución de AWS Lambda. (p. 120).

Paquete de implementación de AWS Lambda en

Ruby
Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función.
Debe crear un paquete de implementación si utiliza la API de Lambda para administrar funciones o si
necesita incluir bibliotecas y dependencias distintas del AWS SDK. Puede cargar el paquete directamente
en Lambda o utilizar un bucket de Amazon S3 y, a continuación, cargarlo en Lambda. Si el paquete de
implementación tiene más de 50 MB, debe usar Amazon S3.

Si utiliza el editor de consola (p. 6) de Lambda para crear la función, la consola administra el paquete de
implementación. Puede utilizar este método siempre y cuando no tenga que añadir ninguna biblioteca.
También puede utilizarlo para actualizar una función que ya tenga bibliotecas en el paquete de
implementación, siempre y cuando el tamaño total no supere el 3 MB.

319
 AWS Lambda Guía para desarrolladores
Actualización de una función sin dependencias

Note

Para que el tamaño del paquete de implementación sea reducido, empaquete las dependencias
de la función en capas. Las capas le permiten administrar las dependencias de forma
independiente, pueden utilizarlas varias funciones y pueden compartirse con otras cuentas. Para
obtener más información, consulte Capas de AWS Lambda (p. 74).

Secciones
• Actualización de una función sin dependencias (p. 320)
• Actualización de una función con dependencias adicionales (p. 320)

Actualización de una función sin dependencias

Para actualizar una función mediante la API de Lambda, utilice la operación
UpdateFunctionCode (p. 598). Cree un archivo que contenga el código de la función y cárguelo con la
AWS CLI.

Para actualizar una función de Ruby sin dependencias

1. Cree un archivo ZIP.

~/my-function$ zip [Link] [Link]

2. Utilice el comando update-function-code para cargar el paquete.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "ruby2.5",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Actualización de una función con dependencias

adicionales
Si la función depende de bibliotecas distintas a AWS SDK parar Ruby, instálelas en un directorio local con
Bundler e inclúyalas en el paquete de implementación.

Para actualizar una función de Ruby con dependencias

1. Instale las bibliotecas en el directorio del proveedor con el comando bundle.

~/my-function$ bundle install --path vendor/bundle

Fetching gem metadata from [Link]

320
 AWS Lambda Guía para desarrolladores
Contexto

Resolving dependencies...
Fetching aws-eventstream 1.0.1
Installing aws-eventstream 1.0.1
...

--path instala las gemas en el directorio del proyecto en lugar de en la ubicación del sistema, y
establece este como la ruta predeterminada para las futuras instalaciones. Para instalar luego gemas
globalmente, utilice la opción --system.
2. Cree un archivo ZIP.

package$ zip -r [Link] [Link] vendor

adding: [Link] (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/cache/[Link] (deflated 36%)
...

3. Actualice el código de la función.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"Runtime": "ruby2.5",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSize": 300,
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Objeto context de AWS Lambda en Ruby

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 318). Este objeto
proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el
entorno de ejecución.

Métodos de context

• get_remaining_time_in_millis – Devuelve el número de milisegundos que faltan antes de que se

agote el tiempo de espera.

Propiedades de context

• function_name – El nombre de la función de Lambda.

• function_version – La versión (p. 68) de la función.
• invoked_function_arn – El nombre de recurso de Amazon (ARN) que se utiliza para invocar la
función. Indica si el invocador ha especificado un alias o un número de versión.
• memory_limit_in_mb – La cantidad de memoria que se asigna para la función.

321
 AWS Lambda Guía para desarrolladores
Registro

• aws_request_id – El identificador de la solicitud de invocación.

• log_group_name – El grupo de registros de la función.
• log_stream_name – El flujo de registro para la instancia de la función.
• deadline_ms– La fecha en la que la función agota su tiempo de espera en milisegundos de tiempo
Unix.
• identity – (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• client_context– (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de
la aplicación del cliente.

Registro de funciones de AWS Lambda en Ruby

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

Para generar registros desde el código de su función puede utilizar instrucciones puts o cualquier
biblioteca de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se registran los
valores de las variables de entorno y el objeto de evento.

Example lambda_function.rb

# lambda_function.rb

def handler(event:, context:)

puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end

Para obtener registros más detallados, utilice la biblioteca de registro.

# lambda_function.rb

require 'logger'

def handler(event:, context:)

logger = [Link]($stdout)
[Link]('## ENVIRONMENT VARIABLES')
[Link](ENV.to_a)
[Link]('## EVENT')
[Link](event)
event.to_a
end

La salida de logger incluye la marca de tiempo, el ID de proceso, el nivel de registro y el ID de solicitud.

I, [2019-10-26T10:04:01.689856 #8] INFO 6573a3a0-2fb1-4e78-a582-2c769282e0bd -- : ## EVENT

I, [2019-10-26T10:04:01.689874 #8] INFO 6573a3a0-2fb1-4e78-a582-2c769282e0bd -- :
{"key1"=>"value1", "key2"=>"value2", "key3"=>"value3"}

La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

322
 AWS Lambda Guía para desarrolladores
Registro

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

Example Formato de registro

START RequestId: 50aba555-99c8-4b21-8358-644ee996a05f Version: $LATEST

## ENVIRONMENT VARIABLES
AWS_LAMBDA_FUNCTION_VERSION
$LATEST
AWS_LAMBDA_LOG_GROUP_NAME
/aws/lambda/my-function
AWS_LAMBDA_LOG_STREAM_NAME
2020/01/31/[$LATEST]3f34xmpl069f4018b4a773bcfe8ed3f9
AWS_EXECUTION_ENV
AWS_Lambda_ruby2.5
...
## EVENT
key

323
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

value
END RequestId: 50aba555-xmpl-4b21-8358-644ee996a05f
REPORT RequestId: 50aba555-xmpl-4b21-8358-644ee996a05f Duration: 12.96 ms Billed Duration:
100 ms Memory Size: 128 MB Max Memory Used: 48 MB Init Duration: 117.86 ms
XRAY TraceId: 1-5e34a246-2a04xmpl0fa44eb60ea08c5f SegmentId: 454xmpl46ca1c7d3 Sampled: true

El tiempo de ejecución de Ruby registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 311)
• Mediante la AWS CLI (p. 311)
• Eliminación de registros (p. 312)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

324
 AWS Lambda Guía para desarrolladores
Mediante la AWS CLI

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309

325
 AWS Lambda Guía para desarrolladores
Eliminación de registros

},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

Errores de funciones de AWS Lambda en Ruby

Cuando el código devuelve un error, Lambda genera una representación JSON de este. Este documento
de error aparece en el registro de invocación y, en el caso de las invocaciones síncronas, en la salida.

Example [Link]

def handler(event:, context:)

puts "Processing event..."
[1, 2, 3].first("two")
"Success"
end

Este código da como resultado un error de tipo. Lambda detecta el error y genera un documento JSON con
campos para el mensaje de error, el tipo y el seguimiento de la pila.

{
"errorMessage": "no implicit conversion of String into Integer",
"errorType": "Function<TypeError>",
"stackTrace": [
"/var/task/[Link]:in `first'",
"/var/task/[Link]:in `handler'"
]

326
 AWS Lambda Guía para desarrolladores
Errores

Cuando se invoca la función desde la línea de comandos, la AWS CLI divide la respuesta en dos
documentos. Para indicar que se ha producido un error en la función, la respuesta que se muestra en el
terminal incluye un campo FunctionError. La respuesta o el error que devuelve la función se escribe en
el archivo de salida.

$ aws lambda invoke --function-name my-function [Link]

{
"StatusCode": 200,
"FunctionError": "Unhandled",
"ExecutedVersion": "$LATEST"
}

Examine el archivo de salida para ver el documento de error.

$ cat [Link]
{"errorMessage":"no implicit conversion of String into
Integer","errorType":"Function<TypeError>","stackTrace":["/var/task/[Link]:in
`first'","/var/task/[Link]:in `handler'"]}

Note

El código de estado 200 (correcto) de la respuesta de Lambda indica que no hubo ningún error
en la solicitud que envió a Lambda. Para ver los problemas que generan un código de estado de
error, consulte Errors (p. 529).

Lambda también registra hasta 256 KB del objeto de error en los registros de la función. Para ver los
registros cuando realice la invocación de la función desde la línea de comandos, utilice la opción --log-
type y descodifique la cadena base64 de la respuesta.

$ aws lambda invoke --function-name my-function [Link] --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3 Version: $LATEST
Processing event...
Error raised from handler method
{
"errorMessage": "no implicit conversion of String into Integer",
"errorType": "Function<TypeError>",
"stackTrace": [
"/var/task/[Link]:in `first'",
"/var/task/[Link]:in `handler'"
]
}
END RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3
REPORT RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3 Duration: 22.74 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 18 MB

Para obtener más información acerca de los registros, consulte Registro de funciones de AWS Lambda en
Ruby (p. 322).

En función del origen de eventos, AWS Lambda podría volver a intentar la ejecución de la función de
Lambda que ha generado un error. Por ejemplo, si Kinesis es el origen de eventos, AWS Lambda reintenta
la invocación que produce errores hasta que la función de Lambda se ejecute correctamente o hasta que
los registros del flujo caduquen. Para obtener más información acerca de los reintentos, consulte Control
de errores y reintentos automáticos en AWS Lambda (p. 107).

327
 AWS Lambda Guía para desarrolladores

Creación de funciones de Lambda

con Java
Puede ejecutar Código Java en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 118) para
Java que ejecutan código para procesar eventos. El código se ejecuta en un entorno de Amazon Linux que
incluye las credenciales de AWS de un rol de AWS Identity and Access Management (IAM) administrado
por usted.

Lambda admite los siguientes entornos de ejecución de Java.

Runtimes de Java

Nombre Identificador JDK Sistema operativo

Java 11 java11 amazon-corretto-11 Amazon Linux 2

Java 8 java8 java-1.8.0-openjdk Amazon Linux

Las funciones de Lambda utilizan un rol de ejecución (p. 32) para obtener permiso para escribir registros
en Amazon CloudWatch Logs y para tener acceso a otros servicios y recursos. Si aún no tiene un rol de
ejecución para el desarrollo de funciones, cree uno.

Para crear un rol de ejecución

1. Abra la página Roles en la consola de IAM.

2. Elija Create role (Crear rol).
3. Cree un rol con las propiedades siguientes.

• Trusted entity (Entidad de confianza) – Lambda.

• Permisos – AWSLambdaVPCAccessExecutionRole..
• Role name (Nombre de rol): lambda-role.

La política AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para escribir

registros a CloudWatch Logs.

Puede agregar permisos al rol más tarde o cambiarlo por otro rol específico para una sola función.

Para crear una función de Java

1. Abra la consola de Lambda.

2. Elija Create function (Crear función).
3. Configure los siguientes ajustes:

• Name (Nombre): my-function.

• Runtime (Tiempo de ejecución): Java 11.

328
 AWS Lambda Guía para desarrolladores
Paquete de implementación

• Role (Rol): Choose an existing role (Elija un rol existente).

• Existing role (Rol existente): lambda-role.
4. Elija Create function (Crear función).
5. Para configurar un evento de prueba, seleccione Test (Prueba).
6. Para Event name (Nombre de evento), escriba test.
7. Seleccione Create.
8. Para ejecutar la función, seleccione Test (Prueba).

La consola crea una función de Lambda con una clase de controlador denominada Hello. Dado que Java
es un lenguaje compilado, no puede ver ni editar el código fuente en la consola de Lambda, pero puede
modificar su configuración, invocarla y configurar disparadores.

La clase Hello cuenta con una función denominada handleRequest que toma un objeto de evento
y un objeto context. Esta es la función de controlador (p. 335) a la que llama Lambda cuando se
invoca la función. El tiempo de ejecución de la función de Java obtiene los eventos de invocación
de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador es
[Link]::handleRequest.

Para actualizar el código de la función, cree un paquete de implementación, que es un archivo ZIP que
contiene el código de la función. A medida que avanza su función de desarrollo, querrá almacenar su
código de función en el control del código fuente, agregar bibliotecas y automatizar las implementaciones.
Comience creando un paquete de implementación (p. 329) y actualizando el código en la línea de
comandos.

El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de
invocación. El objeto context (p. 339) contiene información adicional acerca de la invocación, la función y
el entorno de ejecución. Más información disponible en las variables de entorno.

La función de Lambda incluye un grupo de registros de CloudWatch Logs. El tiempo de ejecución de la

función envía detalles sobre cada invocación a CloudWatch Logs. Retransmite cualquier registro que
genere la función (p. 341) durante la invocación. Si la función devuelve un error (p. 347), Lambda
formatea el error y se lo devuelve al invocador.

Temas
• Paquete de implementación AWS Lambda en Java (p. 329)
• AWS Lambda Controlador de funciones Java (p. 335)
• Objeto context AWS Lambda en Java (p. 339)
• AWS Lambda Registro de funciones en Java (p. 341)
• Errores de funciones AWS Lambda en Java (p. 347)
• Instrumentación del código Java en AWS Lambda (p. 352)
• Creación de un paquete de implementación con Eclipse (p. 356)

Paquete de implementación AWS Lambda en Java

Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función
compilados. Puede cargar el paquete directamente en Lambda o utilizar un bucket de Amazon S3 y,
a continuación, cargarlo en Lambda. Si el paquete de implementación tiene más de 50 MB, debe usar
Amazon S3.

AWS Lambda proporciona las siguientes bibliotecas de funciones de Java:

329
 AWS Lambda Guía para desarrolladores
Paquete de implementación

• [Link]:aws-lambda-java-core (obligatoria): define interfaces de métodos de controlador y el

objeto contextual que el entorno de ejecución pasa al controlador. Si define sus propios tipos de entrada,
esta es la única biblioteca que necesita.
• [Link]:aws-lambda-java-events: tipos de entrada de eventos procedentes de servicios que
invocan funciones de Lambda.
• [Link]:aws-lambda-java-log4j2: biblioteca de appender de Log4j 2 que puede usar para
agregar el ID solicitado en la invocación actual a los registros de funciones (p. 341).

Estas bibliotecas están disponibles en el repositorio central de Maven. Agréguelas a la definición de la

compilación de la siguiente manera.

Gradle

dependencies {
implementation '[Link]:aws-lambda-java-core:1.2.0'
implementation '[Link]:aws-lambda-java-events:2.2.7'
runtimeOnly '[Link]:aws-lambda-java-log4j2:1.1.0'
}

Maven

<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>1.2.0</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>aws-lambda-java-events</artifactId>
<version>2.2.7</version>
</dependency>
<dependency>
<groupId>[Link]</groupId>
<artifactId>aws-lambda-java-log4j2</artifactId>
<version>1.1.0</version>
</dependency>
</dependencies>

Para crear un paquete de implementación, compile el código de función y las dependencias en un único
archivo ZIP o Java Archive (JAR). En el caso de Gradle, use el tipo de compilación Zip (p. 331). En el
caso de Maven, use el complemento Maven Shade (p. 332).
Note

Para que el tamaño del paquete de implementación sea reducido, empaquete las dependencias
de la función en capas. Las capas le permiten administrar las dependencias de forma
independiente, pueden utilizarlas varias funciones y pueden compartirse con otras cuentas. Para
obtener más información, consulte Capas de AWS Lambda (p. 74).

Puede cargar el paquete de implementación a través de la consola de Lambda, la API de Lambda o AWS
SAM.

Para cargar un paquete de implementación con la consola de Lambda

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.

330
 AWS Lambda Guía para desarrolladores
Compilación de un paquete de implementación con Gradle

3. En Function code (Código de función), elija Upload (Cargar).

4. Cargue el paquete de implementación.
5. Elija Save (Guardar).

Secciones
• Compilación de un paquete de implementación con Gradle (p. 331)
• Compilación de un paquete de implementación con Maven (p. 332)
• Carga de un paquete de implementación con la API de Lambda (p. 333)
• Carga de un paquete de implementación con AWS SAM (p. 334)

Compilación de un paquete de implementación con

Gradle
Utilice el tipo de compilación Zip para crear un paquete de implementación con el código de la función y
las dependencias.

Example [Link]: tarea de compilación

task buildZip(type: Zip) {

from compileJava
from processResources
into('lib') {
from [Link]
}
}

Esta configuración de compilación produce un paquete de implementación en la carpeta build/

distributions. La tarea compileJava compila las clases de la función. La tarea processResources
copia las bibliotecas del classpath de la compilación en una carpeta llamada lib.

Example [Link]: dependencias

dependencies {
implementation platform('[Link]:bom:2.10.73')
implementation '[Link]:lambda'
implementation '[Link]:aws-lambda-java-core:1.2.0'
implementation '[Link]:aws-lambda-java-events:2.2.7'
implementation '[Link]:gson:2.8.6'
implementation '[Link].log4j:log4j-api:2.13.0'
implementation '[Link].log4j:log4j-core:2.13.0'
runtimeOnly '[Link].log4j:log4j-slf4j18-impl:2.13.0'
runtimeOnly '[Link]:aws-lambda-java-log4j2:1.1.0'
testImplementation '[Link]:junit-jupiter-api:5.6.0'
testRuntimeOnly '[Link]:junit-jupiter-engine:5.6.0'
}

Lambda carga los archivos JAR en orden alfabético Unicode. Si hay varios archivos JAR en la carpeta lib
que contienen la misma clase, se utiliza el primero. Puede utilizar el siguiente script de shell para identificar
las clases duplicadas.

Example [Link]

mkdir -p expanded

331
 AWS Lambda Guía para desarrolladores
Compilación de un paquete de implementación con Maven

unzip path/to/my/[Link] -d expanded

find ./expanded/lib -name '*.jar' | xargs -n1 zipinfo -1 | grep '.*.class' | sort | uniq -c
| sort

Compilación de un paquete de implementación con

Maven
Para crear un paquete de implementación con Maven, use el complemento Maven Shade. El complemento
crea un archivo JAR que contiene el código compilado de la función y todas sus dependencias.

Example [Link]: configuración del complemento

<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>

Para crear el paquete de implementación, utilice el comando mvn package.

[INFO] Scanning for projects...

[INFO] -----------------------< [Link]:java-maven >-----------------------
[INFO] Building java-maven-function 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ java-maven ---
[INFO] Building jar: target/[Link]
[INFO]
[INFO] --- maven-shade-plugin:3.2.2:shade (default) @ java-maven ---
[INFO] Including [Link]:aws-lambda-java-core:jar:1.2.0 in the shaded jar.
[INFO] Including [Link]:aws-lambda-java-events:jar:2.2.7 in the shaded jar.
[INFO] Including joda-time:joda-time:jar:2.6 in the shaded jar.
[INFO] Including [Link]:gson:jar:2.8.6 in the shaded jar.
[INFO] Replacing original artifact with shaded artifact.
[INFO] Replacing target/[Link] with target/java-maven-1.0-SNAPSHOT-
[Link]
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.321 s
[INFO] Finished at: 2020-03-03T09:07:19Z
[INFO] ------------------------------------------------------------------------

Este comando genera un archivo JAR en la carpeta target.

Si utiliza la biblioteca de appender (aws-lambda-java-log4j2), también debe configurar un

transformador para el complemento Maven Shade. La biblioteca de transformadores combina versiones de
un archivo de caché que aparecen tanto en la biblioteca de appender como en Log4j.

332
 AWS Lambda Guía para desarrolladores
Carga de un paquete de
implementación con la API de Lambda

Example [Link]: configuración del complemento con el appender Log4j 2

<plugin>
<groupId>[Link]</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.2</version>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<transformers>
<transformer
implementation="[Link].maven_shade_plugin.log4j2_cache_transformer.PluginsCacheFileTransfor
</transformer>
</transformers>
</configuration>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>[Link]</groupId>
<artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
<version>2.13.0</version>
</dependency>
</dependencies>
</plugin>

Carga de un paquete de implementación con la API de

Lambda
Para actualizar el código de una función con la AWS CLI o el SDK de AWS, utilice la operación
UpdateFunctionCode (p. 598) de la API. En el caso de la CLI de AWS, utilice el comando update-
function-code. El siguiente comando carga un paquete de implementación llamado my-
[Link] en el directorio actual.

~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://[Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "java8",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Si el paquete de implementación es mayor que 50 MB, no puede cargarlo directamente. Cárguelo en un

bucket de Amazon S3 y haga que Lambda apunte al objeto. Los comandos de ejemplo siguientes cargan

333
 AWS Lambda Guía para desarrolladores
Carga de un paquete de implementación con AWS SAM

un paquete de implementación en un bucket llamado my-bucket y lo utilizan para actualizar el código de

una función.

~/my-function$ aws s3 cp [Link] s3://my-bucket

upload: [Link] to s3://my-bucket/my-function
~/my-function$ aws lambda update-function-code --function-name my-function \
--s3-bucket my-bucket --s3-key [Link]
{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "java8",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Handler": "[Link]",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}

Puede utilizar este método para cargar paquetes de funciones hasta alcanzar 250 MB (descomprimidos).

Carga de un paquete de implementación con AWS

SAM
Puede usar el Modelo de aplicación sin servidor de AWS para automatizar las implementaciones
del código de función, la configuración y las dependencias. AWS SAM es una extensión de AWS
CloudFormation que proporciona una sintaxis simplificada para definir aplicaciones sin servidor. En la
siguiente plantilla de ejemplo, se define una función con un paquete de implementación en el directorio
build/distributions que usa Gradle.

Example [Link]

AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: An AWS Lambda application that calls the Lambda API.
Resources:
function:
Type: AWS::Serverless::Function
Properties:
CodeUri: build/distributions/[Link]
Handler: [Link]
Runtime: java8
Description: Java function
MemorySize: 512
Timeout: 10
# Function's execution role
Policies:
- AWSLambdaBasicExecutionRole
- AWSLambdaReadOnlyAccess
- AWSXrayWriteOnlyAccess
- AWSLambdaVPCAccessExecutionRole
Tracing: Active

Para crear la función, utilice los comandos package y deploy. Estos comandos son personalizaciones de
la CLI de AWS. Contienen otros comandos que van a cargar el paquete de implementación en Amazon S3,
reescribir la plantilla con el URI del objeto y actualizar el código de la función.

334
 AWS Lambda Guía para desarrolladores
Controlador

El siguiente script de ejemplo ejecuta una compilación de Gradle y carga el paquete de implementación
que crea. Crea una pila de AWS CloudFormation la primera vez que la ejecuta. Si la pila ya existe, el script
la actualiza.

Example [Link]

#!/bin/bash
set -eo pipefail
aws cloudformation package --template-file [Link] --s3-bucket MY_BUCKET --output-
template-file [Link]
aws cloudformation deploy --template-file [Link] --stack-name java-basic --capabilities
CAPABILITY_NAMED_IAM

Para ver un ejemplo completo, consulte las siguientes aplicaciones.

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.
• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

AWS Lambda Controlador de funciones Java

El controlador de la función Lambda es el método del código de la función que procesa eventos. Cuando
se invoca una función, Lambda ejecuta el método del controlador. Si el controlador existe o devuelve una
respuesta, pasará a estar disponible para gestionar otro evento.

En el siguiente ejemplo, la clase Handler define un método de controlador llamado handleRequest. El

método handler toma un evento y un objeto contextual como entrada y devuelve una cadena.

Example [Link]

package example;
import [Link]
import [Link]
import [Link]
...

// Handler value: [Link]

public class Handler implements RequestHandler<Map<String,String>, String>{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Map<String,String> event, Context context)
{
LambdaLogger logger = [Link]();
String response = new String("200 OK");
// log execution details
[Link]("ENVIRONMENT VARIABLES: " + [Link]([Link]()));
[Link]("CONTEXT: " + [Link](context));
// process event
[Link]("EVENT: " + [Link](event));
[Link]("EVENT TYPE: " + [Link]().toString());
return response;
}
}

335
 AWS Lambda Guía para desarrolladores
Elección de los tipos de entrada y salida

El entorno de ejecución de Lambda (p. 118) recibe un evento como una cadena con formato JSON y lo
convierte en un objeto. Pasa el objeto del evento al controlador de la función junto con un objeto contextual
que proporciona detalles sobre la invocación y la función. Es usted quien debe decirle al entorno de
ejecución qué método va a invocar estableciendo el parámetro del controlador en la configuración de la
función.

Formatos de controlador

• [Link]::method: formato completo. Por ejemplo: [Link]::handleRequest.

• [Link]: formato abreviado para las funciones que implementan una interfaz de
controlador (p. 337). Por ejemplo: [Link].

Puede agregar un código de inicialización (p. 19) fuera del método del controlador para reutilizar los
recursos en diferentes invocaciones. Cuando el entorno de ejecución carga el controlador, ejecuta código
estático y el constructor de clases. Los recursos que se crean durante la inicialización permanecen en la
memoria entre las invocaciones y el controlador puede reutilizarlos miles de veces.

En el siguiente ejemplo, el registrador, el serializador y el cliente del SDK de AWS se crean cuando la
función sirve su primer evento. Los eventos que esta misma instancia de la función sirve posteriormente
son mucho más rápidos porque esos recursos ya existen.

Example [Link]: código de inicialización

// Handler value: [Link]

public class Handler implements RequestHandler<SQSEvent, String>{
private static final Logger logger = [Link]([Link]);
private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
private static final LambdaAsyncClient lambdaClient = [Link]();
...
@Override
public String handleRequest(SQSEvent event, Context context)
{
String response = new String();
// call Lambda API
[Link]("Getting account settings");
CompletableFuture<GetAccountSettingsResponse> accountSettings =
[Link]([Link]().build());
// log execution details
[Link]("ENVIRONMENT VARIABLES: " + [Link]([Link]()));
...

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo fáciles de implementar en las
que se muestran diferentes tipos de controladores. Para obtener más información, consulte el final de este
tema (p. 338).

Secciones
• Elección de los tipos de entrada y salida (p. 336)
• Interfaces de controlador (p. 337)
• Ejemplo de código del controlador (p. 338)

Elección de los tipos de entrada y salida

Especifique el tipo de objeto al que se asigna el evento en la firma del método del controlador. En el
ejemplo anterior, el entorno de ejecución de Java deserializa el evento en un tipo que implementa la
interfaz Map<String,String>. Los mapas de cadena a cadena funcionan para eventos planos como los
siguientes:

336
 AWS Lambda Guía para desarrolladores
Interfaces de controlador

Example [Link]: datos del tiempo

{
"temperatureK": 281,
"windKmh": -3,
"humidityPct": 0.55,
"pressureHPa": 1020
}

Sin embargo, el valor de cada campo debe ser una cadena o un número. Si el evento contiene un campo
que tiene un objeto como valor, el entorno de ejecución no puede deserializarlo y devuelve un error.

Elija un tipo de entrada que funcione con los datos del evento que procesa la función. Puede utilizar un tipo
básico, un tipo genérico o un tipo bien definido.

Tipos de entrada

• Integer, Long, Double, etc.: el evento es un número sin formato adicional; por ejemplo, 3.5. El
entorno de ejecución convierte el valor en un objeto del tipo especificado.
• String: el evento es una cadena JSON, incluidas las comillas; por ejemplo, "My string.". El tiempo
de ejecución convierte el valor (sin comillas) en un objeto String.
• Type, Map<String,Type>, etc.: el evento es un objeto JSON. El entorno de ejecución lo deserializa en
un objeto del tipo especificado o una interfaz.
• List<Integer>, List<String>, List<Object>, etc.: el evento es una matriz JSON. El entorno de
ejecución lo deserializa en un objeto del tipo especificado o una interfaz.
• InputStream: el evento es cualquier tipo JSON. El entorno de ejecución pasa una secuencia de bytes
del documento al controlador sin modificaciones. Usted deserializa la entrada y escribe la salida en una
secuencia de salida.
• Tipo de biblioteca: en el caso de los eventos enviados por los servicios de AWS, utilice los tipos de la
biblioteca aws-lambda-java-events (p. 329).

Si define su propio tipo de entrada, debería ser un objeto Java estándar (POJO) mutable y deserializable,
con un constructor predeterminado y unas propiedades predeterminadas para cada campo del evento. Las
claves del evento que no se asignan a una propiedad, así como las propiedades que no están incluidas en
el evento, se eliminan sin errores.

El tipo de salida puede ser un objeto o void. El entorno de ejecución serializa los valores devueltos en
texto. Si la salida es un objeto con campos, el entorno de ejecución lo serializa en un documento JSON. Si
se trata de un tipo que encapsula un valor primitivo, el tiempo de ejecución devuelve una representación de
texto de ese valor.

Interfaces de controlador
La biblioteca aws-lambda-java-core define dos interfaces para los métodos de controlador. Utilice las
interfaces proporcionadas para simplificar la configuración del controlador y validar la firma del método del
controlador en tiempo de compilación.

• [Link]
• [Link]

La interfaz RequestHandler es un tipo genérico que toma dos parámetros: el tipo de entrada y el tipo de
salida. Los dos tipos deben ser objetos. Cuando se utiliza esta interfaz, el entorno de ejecución de Java
deserializa el evento en un objeto con el tipo de entrada y serializa la salida en texto. Utilice esta interfaz si
la serialización integrada funcione con los tipos de entrada y salida.

337
 AWS Lambda Guía para desarrolladores
Ejemplo de código del controlador

Example [Link]: interfaz del controlador

// Handler value: [Link]

public class Handler implements RequestHandler<Map<String,String>, String>{
@Override
public String handleRequest(Map<String,String> event, Context context)

Para usar su propia serialización, implemente la interfaz RequestStreamHandler. Con esta interfaz,
Lambda pasa al controlador una secuencia de entrada y otra secuencia de salida. El controlador lee los
bytes de la secuencia de entrada, escribe en la secuencia de salida y devuelve void.

En el ejemplo siguiente se utilizan unos tipos de lectores y escritores almacenados en el búfer para trabajar
con las secuencias de entrada y salida. Utiliza la biblioteca Gson para la serialización y la deserialización.

Example [Link]

import [Link]
import [Link]
import [Link]
...
// Handler value: [Link]
public class HandlerStream implements RequestStreamHandler {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context
context) throws IOException
{
LambdaLogger logger = [Link]();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream,
[Link]("US-ASCII")));
PrintWriter writer = new PrintWriter(new BufferedWriter(new
OutputStreamWriter(outputStream, [Link]("US-ASCII"))));
try
{
HashMap event = [Link](reader, [Link]);
[Link]("STREAM TYPE: " + [Link]().toString());
[Link]("EVENT TYPE: " + [Link]().toString());
[Link]([Link](event));
if ([Link]())
{
[Link]("WARNING: Writer encountered an error.");
}
}
catch (IllegalStateException | JsonSyntaxException exception)
{
[Link]([Link]());
}
finally
{
[Link]();
[Link]();
}
}
}

Ejemplo de código del controlador

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso de
diferentes tipos de controladores e interfaces. Cada una de las aplicaciones de ejemplo contiene scripts
para facilitar la implementación y la limpieza, una plantilla de AWS SAM y recursos de soporte.

338
 AWS Lambda Guía para desarrolladores
Contexto

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.
• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

Las aplicaciones blank-java y s3-java toman un evento de un servicio de AWS como entrada y
devuelven una cadena. La aplicación java-basic contiene varios tipos de controladores:

• [Link]: toma Map<String,String> como entrada.

• [Link]: toma Integer como entrada.
• [Link]: toma List<Integer> como entrada.
• [Link]: toma InputStream y OutputStream como entrada.
• [Link]: toma String como entrada.
• [Link]: toma un tipo personalizado como entrada.

Para probar diferentes tipos de controlador, solo tiene que cambiar el valor del controlador en la plantilla de
AWS SAM. Para obtener instrucciones detalladas, consulte el archivo readme (léame) de la aplicación de
ejemplo.

Objeto context AWS Lambda en Java

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 335). Este objeto
proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el
entorno de ejecución.

Métodos de context

• getRemainingTimeInMillis() – Devuelve el número de milisegundos que faltan antes de que se

agote el tiempo de espera.
• getFunctionName() – Devuelve el nombre de la función de Lambda.
• getFunctionVersion() – Devuelve la versión (p. 68) de la función.
• getInvokedFunctionArn() – Devuelve el nombre de recurso de Amazon (ARN) que se utiliza para
invocar la función. Indica si el invocador ha especificado un alias o un número de versión.
• getMemoryLimitInMB() – Devuelve la cantidad de memoria que se asigna para la función.
• getAwsRequestId() – Devuelve el identificador de la solicitud de invocación.
• getLogGroupName() – Devuelve el grupo de registros de la función.
• getLogStreamName() – Devuelve el flujo de registro para la instancia de la función.
• getIdentity() – (aplicaciones móviles) Devuelve información acerca de la identidad de Amazon
Cognito que ha autorizado la solicitud.
• getClientContext() – (aplicaciones móviles) Devuelve el contexto del cliente proporcionado a
Lambda por parte de la aplicación del cliente.
• getLogger(): devuelve el objeto logger (p. 341) para la función.

En el ejemplo siguiente, se muestra una función que utiliza el objeto contextual para acceder al registrador
de Lambda.

339
 AWS Lambda Guía para desarrolladores
Contexto

Example [Link]

package example;
import [Link]
import [Link]
import [Link]
...

// Handler value: [Link]

public class Handler implements RequestHandler<Map<String,String>, String>{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Map<String,String> event, Context context)
{
LambdaLogger logger = [Link]();
String response = new String("200 OK");
// log execution details
[Link]("ENVIRONMENT VARIABLES: " + [Link]([Link]()));
[Link]("CONTEXT: " + [Link](context));
// process event
[Link]("EVENT: " + [Link](event));
[Link]("EVENT TYPE: " + [Link]().toString());
return response;
}
}

La función serializa el objeto contextual en JSON y lo registra en su secuencia de registro.

Example Salida del registro

START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST

...
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
...
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration:
200 ms Memory Size: 512 MB Max Memory Used: 90 MB Init Duration: 524.75 ms

La interfaz del objeto contextual está disponible en la biblioteca aws-lambda-java-core. Puede implementar
esta interfaz para crear una clase contextual para las pruebas. En el ejemplo siguiente, se muestra una
clase contextual que devuelve valores ficticios para la mayoría de las propiedades y un registrador de
pruebas en funcionamiento.

Example src/test/java/example/[Link]

package example;

import [Link];
import [Link];
import [Link];
import [Link]

public class TestContext implements Context{

public TestContext() {}
public String getAwsRequestId(){

340
 AWS Lambda Guía para desarrolladores
Contexto en aplicaciones de ejemplo

return new String("495b12a8-xmpl-4eca-8168-160484189f99");

}
public String getLogGroupName(){
return new String("/aws/lambda/my-function");
}
...
public LambdaLogger getLogger(){
return new TestLogger();
}

Para obtener más información sobre los registros, consulte AWS Lambda Registro de funciones en
Java (p. 341).

Contexto en aplicaciones de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso del
objeto contextual. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación
y la limpieza, una plantilla de AWS SAM y recursos de soporte.

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.
• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

Todas las aplicaciones de ejemplo tienen una clase de contextual para las pruebas unitarias. En la
aplicación java-basic, se muestra el uso del objeto contextual para obtener un registrador. Utiliza SLF4J
y Log4J 2 para proporcionar un registrador que funcione con pruebas unitarias locales.

AWS Lambda Registro de funciones en Java

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

Para generar registros desde el código de función, puede utilizar los métodos de [Link] o
cualquier módulo de registro que escriba en stdout o en stderr. La biblioteca aws-lambda-java-
core (p. 329) tiene una clase de registrador llamada LambdaLogger a la que se puede acceder desde el
objeto contextual. La clase de registrador admite registros multilínea.

En el ejemplo siguiente se utiliza el registrador LambdaLogger proporcionado por el objeto contextual.

Example [Link]

// Handler value: [Link]

public class Handler implements RequestHandler<Object, String>{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public String handleRequest(Object event, Context context)

341
 AWS Lambda Guía para desarrolladores
Registro

{
LambdaLogger logger = [Link]();
String response = new String("SUCCESS");
// log execution details
[Link]("ENVIRONMENT VARIABLES: " + [Link]([Link]()));
[Link]("CONTEXT: " + [Link](context));
// process event
[Link]("EVENT: " + [Link](event));
return response;
}
}

Example Formato de registro

START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST

ENVIRONMENT VARIABLES:
{
"_HANDLER": "[Link]",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
EVENT:
{
"records": [
{
"messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
...
}
]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration:
200 ms Memory Size: 512 MB Max Memory Used: 90 MB Init Duration: 524.75 ms

El tiempo de ejecución de Java registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.

342
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

• Sampled: para solicitudes rastreadas, el resultado del muestreo.

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 343)
• Mediante la AWS CLI (p. 343)
• Eliminación de registros (p. 345)
• Registro avanzado con Log4j 2 y SLF4J (p. 345)
• Código de registro de ejemplo (p. 347)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST

343
 AWS Lambda Guía para desarrolladores
Mediante la AWS CLI

"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-

f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",

344
 AWS Lambda Guía para desarrolladores
Eliminación de registros

"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

Registro avanzado con Log4j 2 y SLF4J

Para personalizar la salida del registro, posibilitar el registro durante las pruebas unitarias y registrar las
llamadas del SDK de AWS, utilice Apache Log4j 2 con SLF4J. Log4j es una biblioteca de registros para
programas Java que permite configurar diversos niveles de registro y utilizar bibliotecas de appender.
SLF4J es una biblioteca de fachadas que permite cambiar la biblioteca empleada sin modificar el código de
la función.

Para agregar el ID de la solicitud a los registros de la función, use el appender de la biblioteca aws-lambda-
java-log4j2 (p. 329). En el ejemplo siguiente, se muestra un archivo de configuración de Log4j 2 que
agrega una marca temporal y un ID de solicitud a todos los registros.

Example src/main/resources/[Link]: configuración de appender

<Configuration status="WARN">
<Appenders>
<Lambda name="Lambda">
<PatternLayout>
<pattern>%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n</pattern>
</PatternLayout>
</Lambda>
</Appenders>
<Loggers>
<Root level="INFO">
<AppenderRef ref="Lambda"/>
</Root>
<Logger name="[Link]" level="WARN" />
<Logger name="[Link]" level="DEBUG" />
</Loggers>
</Configuration>

Con esta configuración, en cada línea se antepone la fecha, la hora, el ID de solicitud, el nivel de registro y
el nombre de clase.

Example Formato de registros con appender

START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST

2020-03-18 08:52:43 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 INFO Handler - ENVIRONMENT
VARIABLES:
{
"_HANDLER": "[Link]",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
2020-03-18 08:52:43 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 INFO Handler - CONTEXT:

345
 AWS Lambda Guía para desarrolladores
Registro avanzado con Log4j 2 y SLF4J

{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}

SLF4J es una biblioteca de fachadas para los registros de código Java. En el código de la función,
se utiliza la fábrica del registrador de SLF4J para recuperar un registrador con métodos para niveles
de registro como info() y warn(). En la configuración de compilación, puede incluir la biblioteca
de registros y el adaptador de SLF4J en el classpath. Si cambia las bibliotecas en la configuración de
compilación, puede cambiar el tipo de registrador sin necesidad de modificar el código de la función. Es
necesario utilizar SLF4J para capturar registros de SDK para Java.

En el siguiente ejemplo, la clase de controlador utiliza SLF4J para recuperar un registrador.

Example src/main/java/example/[Link]: el registro se realiza con SLF4J

import [Link];
import [Link];

// Handler value: [Link]

public class Handler implements RequestHandler<SQSEvent, String>{
private static final Logger logger = [Link]([Link]);
Gson gson = new GsonBuilder().setPrettyPrinting().create();
LambdaAsyncClient lambdaClient = [Link]();
@Override
public String handleRequest(SQSEvent event, Context context)
{
String response = new String();
// call Lambda API
[Link]("Getting account settings");
CompletableFuture<GetAccountSettingsResponse> accountSettings =
[Link]([Link]().build());
// log execution details
[Link]("ENVIRONMENT VARIABLES: {}", [Link]([Link]()));
...

La configuración de compilación toma dependencias del entorno de ejecución del appender de Lambda y
del adaptador de SLF4J, y dependencias de implementación de Log4J 2.

Example [Link]: dependencias de registro

dependencies {
implementation platform('[Link]:bom:2.10.73')
implementation platform('[Link]:aws-xray-recorder-sdk-bom:2.4.0')
implementation '[Link]:lambda'
implementation '[Link]:aws-xray-recorder-sdk-core'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-core'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-v2'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-v2-instrumentor'
implementation '[Link]:aws-lambda-java-core:1.2.0'
implementation '[Link]:aws-lambda-java-events:2.2.7'
implementation '[Link]:gson:2.8.6'
implementation '[Link].log4j:log4j-api:2.13.0'
implementation '[Link].log4j:log4j-core:2.13.0'
runtimeOnly '[Link].log4j:log4j-slf4j18-impl:2.13.0'
runtimeOnly '[Link]:aws-lambda-java-log4j2:1.1.0'
testImplementation '[Link]:junit-jupiter-api:5.6.0'
testRuntimeOnly '[Link]:junit-jupiter-engine:5.6.0'
}

346
 AWS Lambda Guía para desarrolladores
Código de registro de ejemplo

Cuando ejecuta el código localmente para realizar pruebas, el objeto contextual con el registrador de
Lambda no está disponible y no hay ningún ID de solicitud que el appender de Lambda pueda utilizar. Para
ver ejemplos de configuraciones de prueba, consulte las aplicaciones de la siguiente sección.

Código de registro de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso
de diferentes configuraciones de registro. Cada una de las aplicaciones de ejemplo contiene scripts para
facilitar la implementación y la limpieza, una plantilla de AWS SAM y recursos de soporte.

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.
• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

En la aplicación de ejemplo java-basic, se muestra una configuración de registro mínima que admite
pruebas de registro. El código del controlador utiliza el registrador de LambdaLogger proporcionado por
el objeto contextual. En el caso de las pruebas, la aplicación utiliza una clase TestLogger personalizada
que implementa la interfaz LambdaLogger con un registrador de Log4j 2. SLF4J se utiliza como fachada
para garantizar la compatibilidad con el SDK de AWS. Las bibliotecas de registro se excluyen de la salida
de compilación para reducir el tamaño del paquete de implementación.

La aplicación de ejemplo blank-java utiliza la configuración básica con los registros del SDK de AWS
y el appender de Log4j 2 de Lambda. Log4j 2 se utiliza en Lambda con un appender personalizado que
agrega el ID de solicitud de invocación a cada línea.

Errores de funciones AWS Lambda en Java

Cuando la función genera un error, Lambda devuelve detalles sobre dicho error al invocador. El cuerpo de
la respuesta que Lambda devuelve contiene un documento JSON con el nombre del error, el tipo de error
y una matriz de marcos de pila. El cliente o el servicio que invocó la función puede solucionar el error o
pasarlo a un usuario final. Puede utilizar excepciones personalizadas para devolver información útil a los
usuarios en caso de que se produzcan errores en el cliente.

Example src/main/java/example/[Link]: excepción en tiempo de ejecución

import [Link];

// Handler value: [Link]

public class HandlerDivide implements RequestHandler<List<Integer>, Integer>{
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public Integer handleRequest(List<Integer> event, Context context)
{
LambdaLogger logger = [Link]();
// process event
if ( [Link]() != 2 )
{
throw new InputLengthException("Input must be an array that contains 2 numbers.");
}
int numerator = [Link](0);
int denominator = [Link](1);

347
 AWS Lambda Guía para desarrolladores
Ver la salida de errores

[Link]("EVENT: " + [Link](event));

[Link]("EVENT TYPE: " + [Link]().toString());
return numerator/denominator;
}
}

Cuando se lanza la función InputLengthException, el entorno de ejecución de Java la serializa en el

siguiente documento.

Example Documento de error (con espacios en blanco agregados)

{
"errorMessage":"Input must contain 2 numbers.",
"errorType":"[Link]",
"stackTrace": [
"[Link]([Link])",
"[Link]([Link])"
]
}

En este en, InputLengthException es una excepción RuntimeException. La interfaz (p. 337)

RequestHandler no permite excepciones comprobadas. La interfaz RequestStreamHandler permite
que se generen errores IOException.

La instrucción return del ejemplo anterior también puede generar una excepción en tiempo de ejecución:

return numerator/denominator;

Este código puede devolver un error aritmético.

{"errorMessage":"/ by zero","errorType":"[Link]","stackTrace":
["[Link]([Link])","[Link](Hand

Secciones
• Ver la salida de errores (p. 348)
• Descripción de los tipos y orígenes de errores (p. 350)
• Administración de errores en los clientes (p. 351)
• Administración de errores en otros servicios de AWS (p. 351)
• Administración de errores en aplicaciones de ejemplo (p. 352)

Ver la salida de errores

Puede invocar la función con una carga prueba y ver la salida de errores utilizando la consola de Lambda,
la línea de comandos o el SDK de AWS. La salida de errores también se captura en los registros de
ejecución de la función y, si el seguimiento (p. 352) está habilitado, en AWS X-Ray.

Para ver la salida de errores en la consola de Lambda, invóquela con un evento de prueba.

Para invocar una función en la consola de Lambda

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Elija Configure test events (Configurar eventos de prueba) en el menú desplegable situado junto al
botón Test (Prueba).

348
 AWS Lambda Guía para desarrolladores
Ver la salida de errores

4. Elija una plantilla de evento que se ajuste a los eventos que procesa su función.
5. Asigne un nombre al evento de prueba y modifique la estructura de eventos según sea necesario.
6. Seleccione Create.
7. Elija Test.

La consola de Lambda invoca la función de forma sincrónica (p. 88) y muestra el resultado. Para ver la
respuesta, los registros y otra información, expanda la sección Details (Detalles).

Cuando se invoca la función desde la línea de comandos, la AWS CLI divide la respuesta en dos
documentos. Para indicar que se ha producido un error en la función, la respuesta que se muestra en el
terminal incluye un campo FunctionError. La respuesta o el error que devuelve la función se escribe en
el archivo de salida.

$ aws lambda invoke --function-name my-function [Link]

{
"StatusCode": 200,
"FunctionError": "Unhandled",
"ExecutedVersion": "$LATEST"
}

Examine el archivo de salida para ver el documento de error.

$ cat [Link]
{"errorMessage":"Input must contain 2
numbers.","errorType":"[Link]","stackTrace":
["[Link]([Link])","[Link](Han

Lambda también registra hasta 256 KB del objeto de error en los registros de la función. Para ver los
registros cuando realice la invocación de la función desde la línea de comandos, utilice la opción --log-
type y descodifique la cadena base64 de la respuesta.

$ aws lambda invoke --function-name my-function --payload "[100,0]" [Link] --log-type

Tail \
--query 'LogResult' --output text | base64 -d
START RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f Version: $LATEST
EVENT: [
100,
0
]EVENT TYPE: class [Link]/ by zero: [Link]
[Link]: / by zero
at [Link]([Link])
at [Link]([Link])

END RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f

REPORT RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f Duration: 4.20 ms Billed
Duration: 100 ms Memory Size: 512 MB Max Memory Used: 95 MB
XRAY TraceId: 1-5e73162b-1919xmpl2592f4549e1c39be SegmentId: 3dadxmpl48126cb8
Sampled: true

Para obtener más información acerca de los registros, consulte AWS Lambda Registro de funciones en
Java (p. 341).

349
 AWS Lambda Guía para desarrolladores
Descripción de los tipos y orígenes de errores

Descripción de los tipos y orígenes de errores

Cuando se invoca una función, varios subsistemas administran la solicitud, el evento, la salida y la
respuesta. Los errores pueden provenir del servicio de Lambda (errores de invocación) o de una instancia
de la función. Los errores de la función pueden ser excepciones devueltas por el código del controlador y
excepciones devueltas por el entorno de ejecución de Lambda.

El servicio Lambda recibe la solicitud de invocación y la valida. Comprueba los permisos, que el
documento del evento es un documento JSON válido y los valores de los parámetros. Si el servicio
Lambda encuentra algún error, devuelve un tipo de excepción, mensaje y código de estado HTTP que
indican la causa del error.
Note

Para ver una lista completa de los errores que puede devolver la operación Invoke de la API,
consulte los errores de Invoke (p. 529) en la referencia de la API de Lambda.

Los errores de la serie 4xx del servicio Lambda indican que se trata de un error que el invocador puede
corregir modificando la solicitud, solicitando permiso o intentándolo de nuevo. Los errores de la serie 5xx
indican un problema con el ser Lambda o un problema con la configuración o los recursos de la función.
Estos problemas no puede solucionarlos el invocador, pero pueden sí el propietario de la función.

Si una solicitud pasa la validación, Lambda la envía a una instancia de la función. El entorno de ejecución
convierte el documento del evento en un objeto y se lo pasa al código del controlador. Durante este
proceso, pueden producirse errores si, por ejemplo, el nombre del método del controlador no coincide con
la configuración de la función o si el tiempo de espera de la invocación se agotó antes de que el código del
controlador devolviera una respuesta. Los errores del entorno de ejecución de Lambda tienen un formato
que parece que los devuelve el código, pero los devuelve el entorno de ejecución.

En el ejemplo siguiente, el entorno de ejecución no puede deserializar el evento en un objeto. La entrada

es un tipo JSON válido, pero no coincide con el tipo que esperaba el método de controlador.

Example Error del entorno de ejecución de Lambda

{
"errorMessage": "An error occurred during JSON parsing",
"errorType": "[Link]",
"stackTrace": [],
"cause": {
"errorMessage": "[Link]: Can not
construct instance of [Link] from String value '1000,10': not a valid Integer
value\n at [Source: [Link]@35fc6dc4; line: 1,
column: 1] (through reference chain: [Link][0])",
"errorType": "[Link]",
"stackTrace": [],
"cause": {
"errorMessage": "Can not construct instance of [Link]
from String value '1000,10': not a valid Integer value\n at [Source:
[Link]@35fc6dc4; line: 1, column: 1] (through
reference chain: [Link][0])",
"errorType": "[Link]",
"stackTrace": [

"[Link]([Link])",

"[Link]([Link]
...
]
}
}
}

350
 AWS Lambda Guía para desarrolladores
Administración de errores en los clientes

En los errores del entorno de ejecución de Lambda y en otros errores de la función, el servicio Lambda
no devuelve ningún código de error. Un código de estado de la serie 2xx indica que el servicio Lambda
aceptó la solicitud. En lugar de un código de error, Lambda indica el error incluyendo el encabezado X-
Amz-Function-Error en la respuesta.

En las invocaciones asíncronas, los eventos se ponen en cola antes de que Lambda los envíe a la
función. En las solicitudes válidas, Lambda devuelve una respuesta correcta inmediatamente y agrega el
evento a la cola. Después, Lambda lee los eventos de la cola e invoca la función. Si se produce un error,
Lambda vuelve a intentarlo con un comportamiento que variará según el tipo de error. Para obtener más
información, consulte Invocación asíncrona (p. 89).

Administración de errores en los clientes

Los clientes que invocan funciones Lambda pueden elegir si desean ocuparse de los errores o pasarlos
al usuario final. El comportamiento adecuado en la administración de errores dependerá del tipo de
aplicación, la audiencia y el origen del error. Por ejemplo, si se produce un error en una invocación con el
código 429 (demasiadas solicitudes), la CLI de AWS lo volverá a intentar hasta 4 veces antes de mostrar
un error al usuario.

$ aws lambda invoke --function-name my-function [Link]

An error occurred (TooManyRequestsException) when calling the Invoke operation (reached max
retries: 4): Rate Exceeded.

En otros errores de invocación, el comportamiento correcto dependerá del código de respuesta. La serie
5xx pueden indicar una condición temporal que puede resolverse sin que el usuario tenga que hacer nada.
Volver a intentarlo podría funcionar o no. Los errores de la serie 4xx que no son 429 suelen indicar un
error con la solicitud. No es probable que volver a intentarlo funcione.

En los errores de la función, el cliente puede procesar el documento de error y mostrar el mensaje de error
en un formato sencillo. Una aplicación basada en navegador podría mostrar el mensaje y el tipo de error,
pero omitir el seguimiento de la pila. La CLI de AWS guarda el objeto de error en el archivo de salida y
muestra en su lugar un documento generado a partir de los encabezados de respuesta.

$ aws lambda invoke --function-name my-function --payload '[1000]' [Link]

{
"StatusCode": 200,
"FunctionError": "Unhandled",
"ExecutedVersion": "$LATEST"
}

Example [Link]

{"errorMessage":"Input must be an array that contains 2

numbers.","errorType":"[Link]","stackTrace":
["[Link]([Link])","[Link](Hand

Administración de errores en otros servicios de AWS

Cuando un servicio de AWS invoca la función, el servicio elige el tipo de invocación y el comportamiento
que va a adoptar respecto a los reintentos. Los servicios de AWS pueden invocar la función en función de
un calendario, en respuesta a un evento del ciclo de vida de un recurso o para atender una solicitud de un
usuario. Algunos servicios invocan funciones de forma asíncrona y permiten que Lambda administre los
errores, mientras que otros vuelven a intentarlo o pasan los errores al usuario.

Por ejemplo, API Gateway trata todos los errores de invocación y función como errores internos. Si la
API de Lambda rechaza la solicitud de invocación, API Gateway devuelve un código de error 500. Si

351
 AWS Lambda Guía para desarrolladores
Administración de errores en aplicaciones de ejemplo

la función se ejecuta pero devuelve un error o devuelve una respuesta con un formato incorrecto, API
Gateway muestra un error 502. Para personalizar la respuesta del error, debe detectar errores en el código
y elaborar una respuesta en el formato que desee.

Para determinar el origen de un error y su causa, use AWS X-Ray. Con X-Ray, puede saber en qué
componente se produjo un error y ver los detalles sobre las excepciones. En el ejemplo siguiente, se
muestra un error de una función que generó una respuesta 502 de API Gateway.

Para empezar a utilizar X-Ray, habilite el seguimiento activo (p. 352) en las funciones.

Para obtener información detallada sobre otros errores del controlador de servicios, consulte los temas del
capítulo Uso de AWS Lambda con otros servicios (p. 153).

Administración de errores en aplicaciones de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso de
los errores. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación y la
limpieza, una plantilla de AWS SAM y recursos de soporte.

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.
• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

La función java-basic incluye un controlador (HandlerDivide) que devuelve una excepción en tiempo
de ejecución personalizada. El controlador HandlerStream implementa RequestStreamHandler y
puede generar una excepción comprobada IOException.

Instrumentación del código Java en AWS Lambda

Lambda se integra con AWS X-Ray para permitirle rastrear, depurar y optimizar las aplicaciones de
Lambda. Puede utilizar X-Ray para rastrear una solicitud a medida que esta recorre los recursos de la
aplicación, desde el frontend de la API hasta el almacenamiento y la base de datos del backend. Solo
con agregar la biblioteca de X-Ray SDK a la configuración de compilación, puede registrar los errores y la
latencia de cualquier llamada que realice la función a un servicio de AWS.

El mapa de servicio de X-Ray muestra el flujo de solicitudes de la aplicación. El siguiente ejemplo de la

aplicación de ejemplo de procesamiento de errores (p. 141) muestra una aplicación con dos funciones. La
función principal procesa eventos y, a veces, devuelve errores. La segunda función procesa los errores
que aparecen en el grupo de registros de la primera y utiliza AWS SDK para llamar a X-Ray, Amazon S3 y
Amazon CloudWatch Logs.

352
 AWS Lambda Guía para desarrolladores
Rastreo

Puede habilitar el rastreo en la configuración de la función.

Para habilitar el rastreo activo

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En AWS X-Ray, elija Active tracing (Rastreo activo).
4. Elija Save (Guardar).

Su función necesita permiso para cargar datos de rastreo en X-Ray. Cuando habilita el rastreo activo en la
Lambda consola, Lambda agrega los permisos necesarios al rol de ejecución (p. 32) de la función. De lo
contrario, agregue la política AWSXRayDaemonWriteAccess al rol de ejecución.

X-Ray aplica un algoritmo de muestreo para garantizar que el rastreo sea eficiente, al tiempo que
proporciona una muestra representativa de las solicitudes a las que sirve la aplicación. La regla de
muestreo predeterminada es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales.

Cuando el rastreo activo está habilitado, Lambda registra el rastreo de un subconjunto de invocaciones.
Lambda registra dos segmentos, lo que crea dos nodos en el mapa de servicio. El primer nodo representa
el servicio de Lambda que recibe la solicitud de invocación. El tiempo de ejecución (p. 17) de la función
registra el segundo nodo.

353
 AWS Lambda Guía para desarrolladores
Habilitación del seguimiento activo con la API de Lambda

Para registrar los detalles sobre las llamadas a otros recursos y servicios que realiza la función, agregue
el SDK para Java de X-Ray a la configuración de compilación. En el siguiente ejemplo, se muestra una
configuración de compilación de Gradle que incluye las bibliotecas que permiten la instrumentación
automática de los clientes de AWS SDK para Java 2.x.

Example [Link]: dependencias de seguimiento

dependencies {
implementation platform('[Link]:bom:2.10.73')
implementation platform('[Link]:aws-xray-recorder-sdk-bom:2.4.0')
implementation '[Link]:lambda'
implementation '[Link]:aws-xray-recorder-sdk-core'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-core'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-v2'
implementation '[Link]:aws-xray-recorder-sdk-aws-sdk-v2-instrumentor'
...
}

También puede instrumentar clientes HTTP, registrar consultas SQL y crear subsegmentos personalizados
con anotaciones y metadatos. Para obtener más información, consulte SDK de AWS X-Ray para Java en
Guía para desarrolladores de AWS X-Ray.

Habilitación del seguimiento activo con la API de

Lambda
Para administrar la configuración de seguimiento con la CLI de AWS o el SDK de AWS, utilice las
siguientes operaciones de API.

• UpdateFunctionConfiguration (p. 605)

• GetFunctionConfiguration (p. 505)
• CreateFunction (p. 466)

El siguiente comando de la AWS CLI de ejemplo habilita el rastreo activo en una función llamada «my-
function».

$ aws lambda update-function-configuration --function-name my-function \

--tracing-config Mode=Active

El modo de seguimiento forma parte de la configuración específica de la versión, que se bloquea cuando
se publica una versión de la función. No se puede cambiar el modo de seguimiento de una versión
publicada.

Habilitación del seguimiento activo con AWS

CloudFormation
Para habilitar el seguimiento activo en un recurso de AWS::Lambda::Function de una plantilla de AWS
CloudFormation, utilice la propiedad TracingConfig.

Example [Link]: configuración de seguimiento

Resources:
function:
Type: AWS::Lambda::Function
Properties:

354
 AWS Lambda Guía para desarrolladores
Seguimiento en las aplicaciones de ejemplo

TracingConfig:
Mode: Active
...

En el caso de los recursos de AWS SAM AWS::Serverless::Function, utilice la propiedad Tracing.

Example [Link]: configuración de seguimiento

Resources:
function:
Type: AWS::Serverless::Function
Properties:
CodeUri: build/distributions/[Link]
Tracing: Active
...

Si utiliza el SDK de X-Ray para instrumentar el código de las funciones de los clientes del SDK
de AWS, el paquete de implementación puede llegar a ser bastante grande. Para evitar que se
carguen dependencias en tiempo de ejecución cada vez que se actualice el código de las funciones,
empaquételas en una capa de Lambda (p. 74). En el ejemplo siguiente, se muestra un recurso de
AWS::Serverless::LayerVersion que almacena el SDK para Java de SDK para Java y X-Ray.

Example [Link]: capa de dependencias

Resources:
function:
Type: AWS::Serverless::Function
Properties:
CodeUri: build/distributions/[Link]
Tracing: Active
Layers:
- !Ref libs
...
libs:
Type: AWS::Serverless::LayerVersion
Properties:
LayerName: blank-java-lib
Description: Dependencies for the blank-java sample app.
ContentUri: build/[Link]
CompatibleRuntimes:
- java8

Con esta configuración, solo actualiza los JAR de la biblioteca si se modifican las dependencias de
compilación. Cuando actualice el código de la función, solo tendrá que cargar las clases compiladas de la
función, por lo que los tiempos de carga pueden ser mucho más rápidos.

Para crear una capa de dependencias, es necesario realizar cambios en la configuración de compilación
para generar el archivo de capas antes de la implementación. Consulte la aplicación java-basic para ver un
ejemplo.

Seguimiento en las aplicaciones de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso del
seguimiento. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación y la
limpieza, una plantilla de AWS SAM y recursos de soporte.

Aplicaciones de ejemplo de Java

• java-basic: función mínima de Java con pruebas unitarias y configuración de registro de variables.
Incluye compilaciones de Gradle y Maven.

355
 AWS Lambda Guía para desarrolladores
Tutorial: IDE de Eclipse

• blank-java: función de Java con la biblioteca de eventos, configuración de registro avanzada y AWS
SDK para Java 2.x que llama a la API de Lambda para recuperar la configuración de la cuenta.
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.

Todas las aplicaciones de ejemplo tienen activado el seguimiento activo de las funciones Lambda. En la
aplicación blank-java, se muestra la instrumentación automática de los clientes de AWS SDK para Java
2.x, la administración de segmentos para pruebas, subsegmentos personalizados y el uso de capas de
Lambda para almacenar dependencias en tiempo de ejecución.

En este ejemplo de la aplicación blank-java, se muestran los nodos del servicio Lambda, una función
y la API de Lambda. La función llama a la API de Lambda para monitorear el uso del almacenamiento en
Lambda.

Creación de un paquete de implementación con

Eclipse
Esta sección muestra cómo empaquetar el código Java en un paquete de implementación utilizando el IDE
de Eclipse y el complemento Maven para Eclipse.
Note
El conjunto de herramientas de Eclipse para el SDK de AWS ofrece un complemento de Eclipse
que permite crear un paquete de implementación y cargarlo para crear una función de Lambda.
Si utiliza el IDE de Eclipse como entorno de desarrollo, este complemento le permite crear código
Java, crear y cargar un paquete de implementación y crear una función de Lambda. Para obtener
más información, consulte Guía de introducción a AWS Toolkit for Eclipse. Para ver un ejemplo de
cómo utilizar el kit de herramientas para crear funciones de Lambda, consulte Uso de Lambda con
AWS Toolkit para Eclipse.

Temas
• Requisitos previos (p. 356)
• Creación y compilación de un proyecto (p. 357)

Requisitos previos
Instale el complemento Maven para Eclipse.

1. Inicie Eclipse. En el menú Help de Eclipse, elija Install New Software.

2. En la ventana Install (Instalar), escriba [Link]
releases en el cuadro Work with: (Funciona con) y elija Add (Añadir).
3. Siga los pasos para completar la configuración.

356
 AWS Lambda Guía para desarrolladores
Creación y compilación de un proyecto

Creación y compilación de un proyecto

En este paso, iniciará Eclipse y creará un proyecto de Maven. Añadirá las dependencias necesarias y
creará el proyecto. La compilación producirá un archivo .jar, que es el paquete de implementación.

1. Cree un nuevo proyecto de Maven en Eclipse.

a. En el menú File, elija New, seguido de Project.

b. En la ventana New Project, elija Maven Project.
c. En la ventana New Maven Project, elija Create a simple project y deje el resto de selecciones con
sus valores predeterminados.
d. En las ventanas New Maven Project y Configure project, escriba la siguiente información para
Artifact:

• Group Id: doc-examples

• Artifact Id: lambda-java-example
• Version: 0.0.1-SNAPSHOT
• Packaging: jar
• Name: lambda-java-example
2. Añada la dependencia aws-lambda-java-core al archivo [Link].

Proporciona definiciones de las interfaces RequestHandler, RequestStreamHandler y Context.

Esto le permite compilar código que puede utilizar con AWS Lambda.

a. Abra el menú contextual (haga clic con el botón derecho) del archivo [Link], elija Maven y, a
continuación, Add Dependency.
b. En las ventanas Add Dependency, escriba los siguientes valores:

Group Id: [Link]

Artifact Id: aws-lambda-java-core

Versión: 1.2.0
Note

Si está siguiendo otros temas del tutorial de esta guía, es posible que los tutoriales
específicos le soliciten añadir más dependencias. Asegúrese de añadir las dependencias
que sean necesarias.
3. Añada la clase de Java al proyecto.

a. Abra el menú contextual (haga clic con el botón derecho) del subdirectorio src/main/java del
proyecto, elija New y, a continuación, Class.
b. En la ventana New Java Class, escriba los siguientes valores:

• Package (Paquete): example

• Name (Nombre): Hello
Note

Si está siguiendo otros temas del tutorial de esta guía, es posible que los tutoriales
específicos le recomienden un nombre de paquete o de clase diferente.
c. Añada el código Java. Si está siguiendo otros temas del tutorial de esta guía, añada el código
proporcionado.
4. Compile el proyecto. 357
 AWS Lambda Guía para desarrolladores
Creación y compilación de un proyecto

Abra el menú contextual (haga clic con el botón derecho) del proyecto en Package Explorer y elija
Run As, seguido de Maven Build.... En la ventana Edit Configuration (Editar configuración), escriba
package en el cuadro Goals (Objetivos).
Note

El archivo .jar resultante, [Link], no es

el archivo .jar independiente final que puede utilizar en el paquete de implementación.
En el siguiente paso, añadirá el maven-shade-plugin de Apache para crear el .jar.
independiente. Para obtener más información, vaya a Apache Maven Shade Plugin.
5. Añada el complemento maven-shade-plugin y vuelva a compilar.

El complemento maven-shade-plugin tomará los artefactos (archivos .jar) producidos por el objetivo
package (produce archivos .jar de código de cliente), y creará un archivo .jar independiente que
contiene el código de cliente compilado, así como las dependencias resueltas de [Link].

a. Abra el menú contextual (haga clic con el botón derecho) del archivo [Link], elija Maven y, a
continuación, Add Plugin.
b. En la ventana Add Plugin, escriba los siguientes valores:

• Group Id: [Link]

• Artifact Id: maven-shade-plugin
• Versión: 3.2.2
c. Vuelva a compilar de nuevo.

Esta vez crearemos el archivo .jar como antes y, a continuación, utilizaremos el complemento
maven-shade-plugin para extraer las dependencias y crear el .jar independiente

i. Abra el menú contextual (haga clic con el botón derecho) del proyecto, elija Run As y, a
continuación Maven build....
ii. En las ventanas Edit Configuration (Editar configuración), escriba package shade:shade
en el cuadro Goals (Objetivos).
iii. Elija Run.

Puede encontrar el archivo .jar independiente resultante (es decir, el paquete de

implementación), en el subdirectorio /target .

Abra el menú contextual (haga clic con el botón derecho) del subdirectorio /target
y elija Show In, seguido de System Explorer; encontrará el archivo lambda-java-
[Link].

358
 AWS Lambda Guía para desarrolladores
Paquete de implementación

Creación de funciones de Lambda

con Go
En las secciones siguientes se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en Go.

Runtimes de Go

Nombre Identificador Sistema operativo

Go 1.x go1.x Amazon Linux

AWS Lambda proporciona las siguientes bibliotecas para Go:

• [Link]/aws/aws-lambda-go/lambda: la implementación del modelo de programación de Lambda

para Go. AWS Lambda utiliza este paquete para invocar su controlador (p. 360).
• [Link]/aws/aws-lambda-go/lambdacontext: Elementos auxiliares para obtener acceso a la
información del objeto del contexto (p. 364).
• [Link]/aws/aws-lambda-go/events: esta biblioteca proporciona definiciones de tipos para las
integraciones de orígenes de eventos comunes.

Temas
• AWS Lambda Paquete de implementación en Go (p. 359)
• AWS Lambda Controlador de funciones en Go (p. 360)
• Objeto context AWS Lambda en Go (p. 364)
• AWS Lambda Registro de funciones en Go (p. 365)
• AWS Lambda Errores de funciones en Go (p. 369)
• Instrumentación del código Go en AWS Lambda (p. 369)
• Uso de variables de entorno (p. 371)

AWS Lambda Paquete de implementación en Go

Para crear una función de Lambda, primero debe crear un paquete de implementación de la función de
Lambda, que es un archivo .zip que contiene el código (un ejecutable Go) y las dependencias.

Después de crear un paquete de implementación, puede cargarlo directamente o cargar primero el

archivo .zip en un bucket de Amazon S3 de la misma región de AWS en la que desea crear la función de
Lambda y, a continuación, especificar el nombre del bucket y el nombre de la clave de objeto cuando crea
la función de Lambda mediante la consola o la CLI de AWS.

Descargue la biblioteca de Lambda para Go con go get y compile el ejecutable.

~/my-function$ go get [Link]/aws/aws-lambda-go/lambda

359
 AWS Lambda Guía para desarrolladores
Creación de un paquete de implementación en Windows

~/my-function$ GOOS=linux go build [Link]

Establecer GOOS en linux garantiza que el ejecutable compilado es compatible con el tiempo de
ejecución de Go (p. 118), incluso si lo compila en un entorno que no sea Linux.

Cree un paquete de implementación empaquetando el archivo ejecutable en un archivo ZIP y utilice la

AWS CLI para crear una función. El parámetro del controlador debe coincidir con el nombre del archivo
ejecutable que contenga su controlador.

~/my-function$ zip [Link] main

~/my-function$ aws lambda create-function --function-name my-function --runtime go1.x \
--zip-file fileb://[Link] --handler main \
--role arn:aws:iam::123456789012:role/execution_role

Creación de un paquete de implementación en

Windows
Para crear un archivo .zip que funcione en AWS Lambda con Windows, se recomienda instalar la
herramienta build-lambda-zip.
Note

Si aún no lo ha hecho, deberá instalar git y, después, añadir el ejecutable git a la variable de
entorno de Windows %PATH%.

Ejecute el comando siguiente para descargar la herramienta:

[Link] get -u [Link]/aws/aws-lambda-go/cmd/build-lambda-zip

Utilice la herramienta desde su GOPATH. Si tiene una instalación predeterminada de Go, la herramienta
suele estar en %USERPROFILE%\Go\bin. De lo contrario, vaya hasta la ubicación donde instaló el entorno
en tiempo de ejecución de Go y haga lo siguiente:

En [Link], ejecute lo siguiente:

set GOOS=linux
go build -o main [Link]
%USERPROFILE%\Go\bin\[Link] -output [Link] main

En Powershell, ejecute lo siguiente:

$env:GOOS = "linux"
$env:CGO_ENABLED = "0"
$env:GOARCH = "amd64"
go build -o main [Link]
~\Go\Bin\[Link] -output [Link] main

AWS Lambda Controlador de funciones en Go

Una función de Lambda escrita en Go se crea como ejecutable de Go. En el código de la función de
Lambda, debe incluir el paquete [Link]/aws/aws-lambda-go/lambda, que implementa el modelo de
programación de Lambda para Go. Además, debe implementar el código de la función de controlador y
una función main().

360
 AWS Lambda Guía para desarrolladores
Controlador de funciones de
Lambda con tipos estructurados

package main

import (
"fmt"
"context"
"[Link]/aws/aws-lambda-go/lambda"
)

type MyEvent struct {

Name string `json:"name"`
}

func HandleRequest(ctx [Link], name MyEvent) (string, error) {

return [Link]("Hello %s!", [Link] ), nil
}

func main() {
[Link](HandleRequest)
}

Tenga en cuenta lo siguiente:

• package main: en Go, el paquete que contiene func main() debe denominarse siempre main.
• import: utilice esta opción para incluir las bibliotecas que requiere la función de Lambda. En este
ejemplo, incluye:
• context: Objeto context AWS Lambda en Go (p. 364).
• fmt: objeto de formato de Go que se utiliza para dar formato al valor de retorno de la función.
• [Link]/aws/aws-lambda-go/lambda: como se mencionó anteriormente, implementa el modelo de
programación de Lambda para Go.
• func HandleRequest(ctx [Link], name MyEvent) (string, error): esta es la signatura del
controlador de Lambda e incluye el código que se va a ejecutar. Además, los parámetros incluidos
indican lo siguiente:
• ctx [Link]: proporciona información en tiempo de ejecución para la invocación de la función
de Lambda. ctx es la variable que declara para aprovechar la información disponible a través de
Objeto context AWS Lambda en Go (p. 364).
• name MyEvent: tipo de entrada con un nombre de variable de name cuyo valor se devuelve en la
instrucción return.
• string, error: devuelve dos valores: cadena en caso de ejecución correcta e información de error
estándar. Para obtener más información sobre el control de errores personalizado, consulte AWS
Lambda Errores de funciones en Go (p. 369).
• return [Link]("Hello %s!", name), nil: devuelve simplemente un saludo "Hello" formateado con
el nombre que ha proporcionado en el eevnto de entrada. nil indica que no hubo errores y que la
función se ejecutó correctamente.
• func main(): el punto de entrada que ejecuta el código de la función de Lambda. Esto es necesario.

Al añadir [Link](HandleRequest) entre los corchetes del código func main(){}, la

función de Lambda se ejecuta. De acuerdo con los estándares del lenguaje Go, el corchete de apertura
{ debe colocarse directamente al final de la firma de función main.

Controlador de funciones de Lambda con tipos

estructurados
En el ejemplo anterior, el tipo de entrada era una cadena sencilla. Sin embargo, también pueden pasarse
eventos estructurados al controlador de funciones:

361
 AWS Lambda Guía para desarrolladores
Controlador de funciones de
Lambda con tipos estructurados

package main

import (
"fmt"
"[Link]/aws/aws-lambda-go/lambda"
)

type MyEvent struct {

Name string `json:"What is your name?"`
Age int `json:"How old are you?"`
}

type MyResponse struct {

Message string `json:"Answer:"`
}

func HandleLambdaEvent(event MyEvent) (MyResponse, error) {

return MyResponse{Message: [Link]("%s is %d years old!", [Link],
[Link])}, nil
}

func main() {
[Link](HandleLambdaEvent)
}

La solicitud sería similar a la siguiente:

# request
{
"What is your name?": "Jim",
"How old are you?": 33
}

Y la respuesta sería similar a:

# response
{
"Answer": "Jim is 33 years old!"
}

Para que se exporten, los nombres de campo en la estructura de eventos deben estar en mayúsculas.
Para obtener más información acerca de cómo controlar eventos de orígenes de eventos AWS, consulte
aws-lambda-go/events.

Signaturas válidas para los controladores

Al crear un controlador de funciones de Lambda en Go tiene varias opciones, pero debe cumplir las reglas
siguientes:

• El controlador debe ser una función.

• El controlador puede aceptar entre 0 y 2 argumentos. Si hay dos argumentos, el primero debe
implementar [Link].
• El controlador puede devolver entre 0 y 2 argumentos. Si hay un único valor de retorno, este debe
implementar error. Si hay dos valores de retorno, el segundo debe implementar error. Para obtener
más información acerca de cómo implementar la información de control de errores, consulte AWS
Lambda Errores de funciones en Go (p. 369).

362
 AWS Lambda Guía para desarrolladores
Uso del estado global

A continuación se enumeran las signaturas del controlador válidas. TIn y TOut representan los tipos
compatibles con la biblioteca estándar encoding/json. Para obtener más información, consulte func
Unmarshal a fin de saber cómo se deserializan estos tipos.

•
func ()

•
func () error

•
func (TIn), error

•
func () (TOut, error)

•
func ([Link]) error

•
func ([Link], TIn) error

•
func ([Link]) (TOut, error)

•
func ([Link], TIn) (TOut, error)

Uso del estado global

Es posible declarar y modificar variables globales que son independientes del código de controlador de la
función de Lambda. Además, el controlador puede declarar una función init que se ejecute cuando este
se carga. El comportamiento es el mismo en AWS Lambda que en los programas Go estándar. Una sola
instancia de su función de Lambda nunca controlará varios eventos de forma simultánea.

package main

import (
"log"
"[Link]/aws/aws-lambda-go/lambda"
"[Link]/aws/aws-sdk-go/aws/session"
"[Link]/aws/aws-sdk-go/service/s3"
"[Link]/aws/aws-sdk-go/aws"
)

var invokeCount = 0
var myObjects []*[Link]
func init() {
svc := [Link]([Link]())
input := &s3.ListObjectsV2Input{
Bucket: [Link]("examplebucket"),
}
result, _ := svc.ListObjectsV2(input)
myObjects = [Link]
}

func LambdaHandler() (int, error) {

invokeCount = invokeCount + 1
[Link](myObjects)
return invokeCount, nil
}

func main() {
[Link](LambdaHandler)

363
 AWS Lambda Guía para desarrolladores
Contexto

Objeto context AWS Lambda en Go

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 360). Este objeto
proporciona métodos y propiedades con información acerca de la invocación, la función y el entorno de
ejecución.

La biblioteca de contexto de Lambda proporciona las siguientes variables globales, métodos y

propiedades.

Variables globales

• FunctionName: El nombre de la función de Lambda.

• FunctionVersion: La versión (p. 68) de la función.
• MemoryLimitInMB: La cantidad de memoria que se asigna para la función.
• LogGroupName: El grupo de registros de la función.
• LogStreamName: El flujo de registro para la instancia de la función.

Métodos de context

• Deadline: Devuelve la fecha en la que la ejecución agota su tiempo de espera en milisegundos de

tiempo Unix.

Propiedades de context

• InvokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
Indica si el invocador ha especificado un alias o un número de versión.
• AwsRequestID: El identificador de la solicitud de invocación.
• Identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• ClientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
aplicación del cliente.

Acceso a la información del contexto de invocación

Las funciones de Lambda tienen acceso a metadatos acerca de su entorno y la solicitud de invocación.
Se puede obtener acceso en el contexto del paquete. Si el controlador incluye [Link] como
parámetro, Lambda insertará información acerca de su función en la propiedad Value del contexto. Tenga
en cuenta que debe importar la biblioteca lambdacontext para obtener acceso al contenido del objeto
[Link].

package main

import (
"context"
"log"
"[Link]/aws/aws-lambda-go/lambda"
"[Link]/aws/aws-lambda-go/lambdacontext"
)

364
 AWS Lambda Guía para desarrolladores
Registro

func CognitoHandler(ctx [Link]) {

lc, _ := [Link](ctx)
[Link]([Link])
}

func main() {
[Link](CognitoHandler)
}

En el ejemplo anterior, lc es la variable que se usa para consumir la información que el objeto context
capturó y [Link]([Link]) imprime dicha información, en este
caso, CognitoIdentityPoolID.

En el ejemplo siguiente se indica cómo utilizar el objeto context para monitorizar el tiempo que tarda en
ejecutarse la función de Lambda. Esto le permite analizar las expectativas de desempeño y ajustar el
código de su función en consecuencia, si es necesario.

package main

import (
"context"
"log"
"time"
"[Link]/aws/aws-lambda-go/lambda"
)

func LongRunningHandler(ctx [Link]) (string, error) {

deadline, _ := [Link]()
deadline = [Link](-100 * [Link])
timeoutChannel := [Link]([Link](deadline))

for {

select {

case <- timeoutChannel:

return "Finished before timing out.", nil

default:
[Link]("hello!")
[Link](50 * [Link])
}
}
}

func main() {
[Link](LongRunningHandler)
}

AWS Lambda Registro de funciones en Go

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

Para generar registros desde el código de la función, puede utilizar los métodos del paquete fmt o
cualquier biblioteca de registro que escriba en stdout o en stderr. El siguiente ejemplo utiliza
[Link].

365
 AWS Lambda Guía para desarrolladores
Registro

package main

import (
"fmt"
"[Link]/aws/aws-lambda-go/lambda"
)

func HandleRequest() {
[Link]("Hello from Lambda")
}

func main() {
[Link](HandleRequest)
}

Para obtener registros más detallados, utilice el paquete de registro.

package main

import (
"log"
"[Link]/aws/aws-lambda-go/lambda"
)

func HandleRequest() {
[Link]("Event received.")
}

func main() {
[Link](HandleRequest)
}

Example Formato de registro

START RequestId: 6b9702a6-xmpl-487a-a10d-b066d7e8a5e1 Version: $LATEST

END RequestId: 6b9702a6-xmpl-487a-a10d-b066d7e8a5e1
REPORT RequestId: 6b9702a6-xmpl-487a-a10d-b066d7e8a5e1 Duration: 1.07 ms Billed
Duration: 100 ms Memory Size: 512 MB Max Memory Used: 41 MB Init Duration: 204.69 ms
XRAY TraceId: 1-5e34a425-4b30xmple305c998ac423ea5 SegmentId: 6362xmpl0ff64446 Sampled:
true

El tiempo de ejecución de Go registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

366
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 367)
• Mediante la AWS CLI (p. 367)
• Eliminación de registros (p. 369)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

367
 AWS Lambda Guía para desarrolladores
Mediante la AWS CLI

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

368
 AWS Lambda Guía para desarrolladores
Eliminación de registros

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

AWS Lambda Errores de funciones en Go

Puede crear un control de errores personalizado para generar una excepción directamente desde la
función de Lambda y controlarla directamente.

En los siguientes códigos de muestra se ilustra cómo hacerlo. Tenga en cuenta que los errores
personalizados en Go deben importar el módulo errors.

package main

import (
"errors"
"[Link]/aws/aws-lambda-go/lambda"
)

func OnlyErrors() error {

return [Link]("something went wrong!")
}

func main() {
[Link](OnlyErrors)
}

Que devuelve lo siguiente:

{
"errorMessage": "something went wrong!",
"errorType": "errorString"
}

Instrumentación del código Go en AWS Lambda

Puede utilizar el SDK de X-Ray para Go con la función de Lambda. Si su controlador incluye Objeto
context AWS Lambda en Go (p. 364) como primer argumento, ese objeto puede pasarse al SDK
de X-Ray. A través de este contexto, Lambda pasa valores que el SDK puede utilizar para adjuntar
subsegmentos al segmento de servicio de invocación de Lambda. Los subsegmentos creados con el SDK
aparecerán como parte de sus rastros de Lambda.

Instalación del SDK de X-Ray para Go

Utilice el comando siguiente para instalar el SDK de X-Ray para Go. (Se incluirán las dependencias del
SDK que no sean de prueba).

go get -u [Link]/aws/aws-xray-sdk-go/...

Si desea incluir las dependencias de prueba, utilice el comando siguiente:

369
 AWS Lambda Guía para desarrolladores
Configuración del SDK de X-Ray para Go

go get -u -t [Link]/aws/aws-xray-sdk-go/...

También puede utilizar Glide para administrar las dependencias.

glide install

Configuración del SDK de X-Ray para Go

En el ejemplo de código siguiente se muestra cómo configurar el SDK de X-Ray para Go en su función de
Lambda:

import (
"[Link]/aws/aws-xray-sdk-go/xray"
)
func myHandlerFunction(ctx [Link], sample string) {
[Link]([Link]{
LogLevel: "info", // default
ServiceVersion: "1.2.3",
})
... //remaining handler code
}

Creación de un subsegmento
El código siguiente ilustra cómo iniciar un subsegmento:

// Start a subsegment
ctx, subSeg := [Link](ctx, "subsegment-name")
// ...
// Add metadata or annotation here if necessary
// ...
[Link](nil)

Captura
El código siguiente ilustra cómo rastrear y capturar una ruta de código crítica:

func criticalSection(ctx [Link]) {

// This example traces a critical code path using a custom subsegment
[Link](ctx, "[Link]", func(ctx1 [Link]) error {
var err error

[Link]()
result := [Link]()
[Link]()

[Link](ctx1, "ResourceResult", result)

})
}

Rastreo de solicitudes HTTP

También puede utilizar el método [Link]() si desea rastrear un cliente HTTP, tal y como se
muestra a continuación:

370
 AWS Lambda Guía para desarrolladores
Variables de entorno

func myFunction (ctx [Link]) ([]byte, error) {

resp, err := [Link](ctx, [Link](nil), "[Link]
if err != nil {
return nil, err
}
return [Link]([Link]), nil
}

Uso de variables de entorno

Para acceder a las variables de entorno (p. 54) en Go, utilice la función Getenv .

El siguiente ejemplo explica cómo hacerlo. Tenga en cuenta que la función importa el paquete fmt para
formatear los resultados impresos y el paquete os, una interfaz del sistema independiente de la plataforma
que le permite obtener acceso a las variables de entorno.

package main

import (
"fmt"
"os"
"[Link]/aws/aws-lambda-go/lambda"
)

func main() {
[Link]("%s is %s. years old\n", [Link]("NAME"), [Link]("AGE"))

Para obtener una lista de variables de entorno establecidas por el motor de ejecución de Lambda, consulte
Variables de entorno de tiempo de ejecución (p. 56).

371
 AWS Lambda Guía para desarrolladores
Paquete de implementación

Creación de funciones de Lambda

con C#
En las siguientes secciones se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en C#.

AWS Lambda proporciona las siguientes bibliotecas de funciones de C#:

• [Link]: esta biblioteca proporciona un registrador de Lambda estático, interfaces

serialización y un objeto context. El objeto Context (AWS Lambda Objeto context en C# (p. 382))
proporciona información del tiempo de ejecución acerca de la función de Lambda.
• [Link]: es una implementación de la interfaz de serialización de
[Link].
• [Link]: proporciona una biblioteca para el registro desde [Link].
• Objetos de evento (POCOs) para varios servicios de AWS, entre los que se incluyen:
• [Link]
• [Link]
• [Link]
• [Link]
• [Link]
• [Link].S3Events
• [Link]
• [Link]

Estos paquetes están disponibles en Nuget Packages.

Runtimes de .NET

Nombre Identificador Lenguajes Sistema operativo

.NET Core 2.1 dotnetcore2.1 C# Amazon Linux

Powershell Core 6.0

Temas
• AWS Lambda Paquete de implementación en C# (p. 372)
• AWS Lambda Controlador de funciones en C# (p. 378)
• AWS Lambda Objeto context en C# (p. 382)
• AWS Lambda Función de registro en C# (p. 383)
• AWS Lambda Errores de funciones en C# (p. 387)

AWS Lambda Paquete de implementación en C#

Un paquete de implementación de Lambda para .NET Core es un archivo zip del ensamblado compilado
de su función con todas sus dependencias de ensamblado. El paquete también contiene un archivo

372
 AWS Lambda Guía para desarrolladores
CLI de .NET Core

[Link]. Este indica al entorno en tiempo de ejecución de .NET Core todas las dependencias
de su función y un archivo [Link], que se usa para configurar dicho entorno.
El comando publish de la CLI de .NET puede crear una carpeta con todos estos archivos, pero
[Link] no se incluirá de forma predeterminada, porque un proyecto de Lambda
suele configurarse para ser una biblioteca de clases. Para forzar que [Link]
se escriba como parte del proceso de publish, pase el argumento de la línea de comandos: /
p:GenerateRuntimeConfigurationFiles=true to the publish command.

Aunque el paquete de implementación se puede crear con el comando dotnet publish, se

recomienda crearlo con AWS Toolkit for Visual Studio (p. 376) o CLI de .NET Core (p. 373). Estas
son herramientas optimizadas específicamente para Lambda a fin de garantizar que el archivo lambda-
[Link] existe y sirve para optimizar el paquete, incluyendo la eliminación de
dependencias no basadas en Linux.

Temas
• CLI de .NET Core (p. 373)
• AWS Toolkit for Visual Studio (p. 376)

CLI de .NET Core

La CLI de .NET Core ofrece una manera multiplataforma de crear aplicaciones de Lambda basadas
en .NET. En esta sección se presupone que ha instalado la CLI de .NET Core. Si todavía no lo ha hecho,
hágalo aquí.

En la CLI de .NET se usa el comando new para crear proyectos .NET desde una línea de comando. Esto
resulta útil si desea crear un proyecto fuera de Visual Studio. Para ver una lista de los tipos de proyectos
disponibles, abra una línea de comando, vaya hasta la ubicación donde instaló el entorno en tiempo de
ejecución de .NET Core y ejecute el siguiente comando:

dotnet new -all

Usage: new [options]
...
Templates Short Name Language Tags

-------------------------------------------------------------------------------------------------------
Console Application console [C#], F#, VB
Common/Console
Class library classlib [C#], F#, VB
Common/Library
Unit Test Project mstest [C#], F#, VB
Test/MSTest
xUnit Test Project xunit [C#], F#, VB
Test/xUnit
...
Examples:
dotnet new mvc --auth Individual
dotnet new viewstart
dotnet new --help

AWS Lambda ofrece plantillas adicionales a través del paquete NuGet [Link]. Para
instalar este paquete, ejecute el comando siguiente:

dotnet new -i [Link]

Una vez completada la instalación, las plantillas de Lambda; aparecen como parte de dotnet new. Para
examinar los detalles acerca de una plantilla, utilice la opción de ayuda.

373
 AWS Lambda Guía para desarrolladores
CLI de .NET Core

dotnet new [Link] --help

La plantilla [Link] es compatible con las siguientes opciones.

• --name: nombre de la función.

• --profile: el nombre de un perfil en su archivo de credenciales de AWS SDK para .NET.
• --region: la región de AWS en la que crear la función.

Estas opciones se guardan en un archivo denominado [Link].

Cree un proyecto de función con la plantilla [Link].

dotnet new [Link] --name MyFunction

En el directorio src/myfunction, examine los archivos siguientes:

• [Link]: aquí se especifican las opciones de línea de comando al implementar su

función de Lambda. Por ejemplo:

"profile" : "default",
"region" : "us-east-2",
"configuration" : "Release",
"framework" : "netcoreapp2.1",
"function-runtime":"dotnetcore2.1",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "MyFunction::[Link]::FunctionHandler"

• [Link]: el código de la función de controlador de Lambda. Es una plantilla de C# que incluye la

biblioteca [Link] predeterminada y un atributo LambdaSerializer predeterminado.
Para obtener más información acerca de las opciones y los requisitos de serialización, consulte
Serialización de las funciones de Lambda (p. 380). También incluye una función de muestra que puede
editar para aplicar el código de su función de Lambda.

using System;
using [Link];
using [Link];
using [Link];

using [Link];

// Assembly attribute to enable the Lambda function's JSON input to be converted into
a .NET class.
[assembly: LambdaSerializer(typeof([Link]))]

namespace MyFunction
{
public class Function
{

public string FunctionHandler1(string input, ILambdaContext context)

{
return input?.ToUpper();
}
}
}

• [Link]: archivo MSBuild que enumera los archivos y ensamblados que componen la
aplicación.

374
 AWS Lambda Guía para desarrolladores
CLI de .NET Core

<Project Sdk="[Link]">

<PropertyGroup>
<TargetFramework>netcoreapp2.1</TargetFramework>
</PropertyGroup>

<ItemGroup>
<PackageReference Include="[Link]" Version="1.0.0 " />
<PackageReference Include="[Link]" Version="1.3.0" />
</ItemGroup>

</Project>

• Readme: use este archivo para documentar su función de Lambda.

En el myfunction/test directory, examine the following files:

• [Link]: como se ha indicado anteriormente, este es un archivo MSBuild que enumera

los archivos y los ensamblados que componen su proyecto de prueba. Tenga en cuenta que también
incluye la biblioteca [Link], lo que le permite integrar a la perfección cualquier plantilla
de Lambda necesaria para probar la función.

<Project Sdk="[Link]">
...

<PackageReference Include="[Link]" Version="1.0.0 " />

...

• [Link]: el mismo archivo de plantilla de código C# que se incluye en el directorio src. Edite
este archivo para reflejar el código de producción de su función y probarlo antes de cargar su función de
Lambda en un entorno de producción.

using System;
using [Link];
using [Link];
using [Link];

using Xunit;
using [Link];
using [Link];

using MyFunction;

namespace [Link]
{
public class FunctionTest
{
[Fact]
public void TestToUpperFunction()
{

// Invoke the lambda function and confirm the string was upper cased.
var function = new Function();
var context = new TestLambdaContext();
var upperCase = [Link]("hello world", context);

[Link]("HELLO WORLD", upperCase);

}
}
}

375
 AWS Lambda Guía para desarrolladores
AWS Toolkit for Visual Studio

Una vez que la función ha superado las pruebas, puede crearla e implementarla mediante la herramienta
de .NET Core Global [Link]. Para instalar la herramienta de .NET Core Global, ejecute el
siguiente comando.

dotnet tool install -g [Link]

Si ya tiene la herramienta instalada, puede asegurarse de estar utilizando la última versión con el siguiente
comando.

dotnet tool update -g [Link]

Para obtener más información acerca de la herramienta de .NET Core Global [Link],
consulte su repositorio GitHub.

Con las herramientas [Link] instalados, puede implementar su función con el siguiente
comando:

dotnet lambda deploy-function MyFunction --function-role role

Después de la implementación, puede volver a probarla en un entorno de producción con el comando

siguiente y pasar un valor distinto al controlador de la función de Lambda:

dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"

Si todos los aspectos del proceso son correctos, debe ver lo siguiente:

dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"

Payload:
"JUST CHECKING IF EVERYTHING IS OK"

Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 100 ms Memory Size:
256 MB Max Memory Used: 12 MB

AWS Toolkit for Visual Studio

Puede crear aplicaciones de Lambda basadas en .NET mediante el complemento de Lambda para AWS
Toolkit for Visual Studio. El conjunto de herramientas está disponible como unaextensión de Visual Studio.

1. Lance Microsoft Visual Studio y elija New project.

a. En el menú File, elija New, seguido de Project.

b. En la ventana New Project, elija AWS Lambda Project (.NET Core), seguido de OK.
c. En la ventana Select Blueprint, dispondrá de una serie de aplicaciones de ejemplo con código de
muestra para comenzar a crear una aplicación de Lambda basada en .NET.
d. Para crear una aplicación de Lambda desde cero, elija Empty Function (Función vacía), seguido
de Finish (Finalizar).
2. Examine el archivo [Link], que se crea como parte del proyecto.
Puede configurar las opciones de este archivo, que las herramientas de Lambda leerán de forma
predeterminada. Las plantillas de proyecto creadas en Visual Studio definen muchos de estos campos
con valores predeterminados. Observe los campos siguientes:

• profile: el nombre de un perfil en el archivo de credenciales de AWS SDK para .NET.

376
 AWS Lambda Guía para desarrolladores
AWS Toolkit for Visual Studio

• function-handler: aquí es donde se especifica el valor de function handler y por esa razón no
se tiene que definir en el asistente. Sin embargo, siempre que cambie el nombre de Assembly,
Namespace, Class o Function en el código de su función, tendrá que actualizar los campos
correspondientes en [Link] file.

{
"profile":"default",
"region" : "us-east-2",
"configuration" : "Release",
"framework" : "netcoreapp2.1",
"function-runtime":"dotnetcore2.1",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "Assembly::[Link]::Function"
}

3. Abra el archivo [Link]. Se le proporcionará una plantilla para implementar el código del
controlador de la función de Lambda.

4. Una vez que haya escrito el código que representa la función de Lambda, puede cargarlo haciendo
clic con el botón derecho del ratón en el nodo Project (Previsión) de la aplicación y, a continuación,
eligiendo Publish to AWS Lambda (Publicar en AWS Lambda).
5. En la ventana Upload Lambda Function (Cargar función de Lambda), escriba un nombre para la
función o seleccione una función que ya se haya publicado para volver a publicarla. A continuación,
elija Siguiente
6. En la ventana Advanced Function Details (Detalles de función avanzada), configure las siguientes
opciones:

• Role Name (Nombre de rol) (obligatorio): El rol de IAM (p. 32) que AWS Lambda asume cuando
ejecuta la función.
• Environment (Entorno): Pares clave-valor que Lambda establece en el entorno de ejecución. Utilice
variables de entorno (p. 54) para ampliar la configuración de la función fuera del código.
• Memory (Memoria): La cantidad de memoria disponible para la función durante la ejecución. Elija
una cantidad entre 128 MB y 3,008 MB (p. 30), en incrementos de 64 MB.
• Timeout (Tiempo de espera): La cantidad de tiempo que Lambda permite que una función se
ejecute antes de detenerla. El valor predeterminado es de 3 segundos. El valor máximo permitido es
de 900 segundos.
• VPC: Si la función necesita acceso de red a recursos que no están disponibles a través de Internet,
configúrela para que se conecte a una VPC (p. 78).

377
 AWS Lambda Guía para desarrolladores
Controlador

• DLQ: Si la función se invoca de forma asíncrona, elija una cola o un tema (p. 95) para recibir las
invocaciones erróneas.
• Enable active tracing (Habilitar rastreo activo): Realice un muestreo de las solicitudes entrantes y
rastree las solicitudes muestreadas con AWS X-Ray (p. 404).
7. Elija Next seguido de Upload para implementar la aplicación.

Para obtener más información, consulte Implementación de un proyecto de AWS Lambda con la CLI
de .NET Core.

AWS Lambda Controlador de funciones en C#

Cuando cree una función de Lambda debe especificar un controlador que AWS Lambda puede invocar
cuando el servicio ejecute la función en su nombre.

Un controlador de función de Lambda se define como una instancia o un método estático en una clase. Si
desea acceder al objeto context de Lambda, está disponible definiendo un parámetro de método de tipo
ILambdaContext, una interfaz que puede utilizar para obtener acceso a información acerca de la ejecución
actual, como el nombre de la función actual, la cantidad máxima de memoria, el tiempo que falta para
finalizar la ejecución y el registro.

returnType handler-name(inputType input, ILambdaContext context) {

...
}

En la sintaxis, tenga en cuenta lo siguiente:

• inputType: el primer parámetro del controlador es su entrada, que puede estar formada por datos de
eventos (publicados por un origen de eventos) o por una entrada personalizada proporcionada por el
usuario, como una cadena o cualquier objeto de datos personalizado.
• returnType: si piensa invocar la función de Lambda de forma síncrona (utilizando el tipo de invocación
RequestResponse), puede devolver la salida de la función utilizando cualquiera de los tipos de datos
admitidos. Por ejemplo, si utiliza una función de Lambda como backend de aplicaciones móviles, la
invocación se realiza de forma síncrona. El tipo de datos de salida se serializará en JSON.

Si piensa invocar la función de Lambda de forma asíncrona (utilizando el tipo de invocación Event),
returnType debería ser void. Por ejemplo, si utiliza AWS Lambda con orígenes de eventos como
Amazon S3 o Amazon SNS, estos orígenes de eventos invocan la función de Lambda mediante el tipo
de invocación Event.
• ILambdaContext context: el segundo argumento de la firma del controlador es opcional.
Proporciona acceso al objeto context (p. 382) que tiene información sobre la función y la solicitud.

Control de flujos
De forma predeterminada, solo se admite el tipo [Link] como parámetro de entrada.

Por ejemplo, fíjese en el siguiente código de ejemplo de C#.

using [Link];

namespace Example
{
public class Hello
{

378
 AWS Lambda Guía para desarrolladores
Control de tipos de datos estándar

public Stream MyHandler(Stream stream)

{
//function logic
}
}
}

En el código C# del ejemplo, el primer parámetro del controlador es la entrada al controlador (MyHandler),
que puede estar formada por datos de eventos (publicados por un origen de eventos como Amazon S3)
o por una entrada personalizada proporcionada por el usuario, tal como Stream (como sucede en este
ejemplo) o cualquier objeto de datos personalizado. La salida es de tipo Stream.

Control de tipos de datos estándar

Para todos los demás tipos, que se indican a continuación, tendrá que especificar un serializador.

• Tipos primitivos de .NET (como string o int).

• Colecciones y mapas: IList, IEnumerable, IList<T>, Array, IDictionary, IDictionary<TKey, TValue>
• Tipos POCO (objetos CLR estándar simples, o Plain old CLR objects)
• Tipos de eventos predefinidos de AWS
• Para las invocaciones asíncronas, Lambda ignorará el tipo de retorno. El tipo de retorno se puede
establecer en void en estos casos.
• Si está utilizando la programación asíncrona de .NET, el tipo de retorno puede ser Task y Task<T>, y
utilizar las palabras clave async y await. Para obtener más información, consulte Uso de async en
funciones C# con AWS Lambda (p. 381).

A menos que los parámetros de entrada y salida de la función sean del tipo [Link],
deberá serializarlos. AWS Lambda proporciona un serializador predeterminado que se puede aplicar
en el nivel de ensamblado o de método de la aplicación, o puede definir uno implementando la interfaz
ILambdaSerializer proporcionada por la biblioteca [Link]. Para obtener más
información, consulte AWS Lambda Paquete de implementación en C# (p. 372).

Para añadir el atributo serializador predeterminado a un método, primero añada una dependencia de
[Link] en el archivo [Link].

{
"version": "1.0.0-*",
"dependencies":{
"[Link]": {
"type": "platform",
"version": "1.0.1"
},
"[Link]": "1.3.0"
},
"frameworks": {
"netcoreapp1.0": {
"imports": "dnxcore50"
}
}
}

El ejemplo siguiente ilustra la flexibilidad que puede obtenerse especificando el serializador

predeterminado de [Link] en un método y otro elegido por el usuario en otro método:

public class ProductService{

[LambdaSerializer(typeof([Link]))]
public Product DescribeProduct(DescribeProductRequest request)

379
 AWS Lambda Guía para desarrolladores
Signaturas para los controladores

{
return [Link]([Link]);
}

[LambdaSerializer(typeof(MyJsonSerializer))]
public Customer DescribeCustomer(DescribeCustomerRequest request)
{
return [Link]([Link]);
}
}

Signaturas para los controladores

Cuando cree funciones de Lambda, debe proporcionar una cadena de controlador que indique a AWS
Lambda dónde debe buscar el código que va a invocar. En C#, tiene este formato:

ENSAMBLADO::TIPO::MÉTODO, donde:

• ENSAMBLADO es el nombre del archivo de ensamblado de .NET para la aplicación. Cuando utilice la
CLI de .NET Core para compilar la aplicación, si no ha establecido el nombre del ensamblado con la
opción [Link] en [Link], el nombre de ENSAMBLADO será el nombre de
la carpeta que contiene el archivo project. json. Para obtener más información, consulte CLI de .NET
Core (p. 373). En este caso, supongamos que el nombre de la carpeta es HelloWorldApp.
• TIPO es el nombre completo del tipo de controlador, que consta del EspacioDeNombres y del
NombreDeLaClase. En este caso [Link].
• MÉTODO es el nombre del controlador de la función, en este caso, MyHandler.

En definitiva, la signatura tendrá este formato:

Ensamblado::[Link]::NombreDelMétodo.

Ahora, considere el siguiente ejemplo:

using [Link];

namespace Example
{
public class Hello
{
public Stream MyHandler(Stream stream)
{
//function logic
}
}
}

La cadena del controlador sería: HelloWorldApp::[Link]::MyHandler.

Important

Si el método especificado en la cadena de controlador está sobrecargado, debe proporcionar la

signatura exacta del método que Lambda debe invocar. AWS Lambda rechazará una signatura
que de otra forma sería válida si la resolución requeriría seleccionar entre varias signaturas
(sobrecargadas).

Serialización de las funciones de Lambda

Para las funciones de Lambda que utilizan tipos de entrada o salida distintos de un objeto Stream, tendrá
que añadir una biblioteca de serialización a la aplicación. Puede hacerlo de las siguientes maneras:

380
 AWS Lambda Guía para desarrolladores
Restricciones del controlador de funciones de Lambda

• Utilice el paquete [Link] de NuGet. Esta biblioteca utiliza

[Link] para gestionar la serialización.
• Creando su propia biblioteca de serialización mediante la implementación de la interfaz
ILambdaSerializer, que está disponible formando parte de la biblioteca [Link]. La
interfaz define dos métodos:
• T Deserialize<T>(Stream requestStream);

Puede implementar este método para deserializar la carga de solicitud desde la API Invoke en el
objeto que se pasa al controlador de la función de Lambda.
• T Serialize<T>(T response, Stream responseStream);.

Puede implementar este método para serializar el resultado que devuelve el controlador de la función
de Lambda en la carga de respuesta que devuelve la API Invoke.

Puede utilizar cualquier serializador que desee añadiéndolo como una dependencia al archivo
[Link].

...
<ItemGroup>
<PackageReference Include="[Link]" Version="1.0.0" />
<PackageReference Include="[Link]" Version="1.3.0" />
</ItemGroup>

Seguidamente, deberá añadirlo a su archivo [Link]. Por ejemplo, si utiliza el serializador

predeterminado de [Link], esto es lo que debería añadir:

[assembly:LambdaSerializer(typeof([Link]))]

Note

Puede definir un atributo de serialización personalizado en el nivel de método, que sustituirá

al serializador predeterminado especificado en el nivel de ensamblado. Para obtener más
información, consulte Control de tipos de datos estándar (p. 379).

Restricciones del controlador de funciones de Lambda

Tenga en cuenta que existen algunas restricciones que afectan a la firma del controlador.

• No puede ser unsafe ni utilizar tipos de puntero en la signatura del controlador, aunque el contexto
unsafe puede utilizarse dentro del método del controlador y sus dependencias. Para obtener más
información, consulte unsafe (Referencia de C#).
• No puede pasar un número variable de parámetros utilizando la palabra clave params, ni utilizar
ArgIterator como parámetro de entrada o de retorno que se utiliza para admitir un número variable
de parámetros.
• El controlador no puede ser un método genérico (por ejemplo, IList<T> Sort<T>(IList<T> input)).
• No se admiten los controladores asíncronos con la signatura async void.

Uso de async en funciones C# con AWS Lambda

Si sabe que la función de Lambda requerirá un proceso de larga duración, como cargar archivos grandes
en Amazon S3 o leer una gran cantidad de registros desde DynamoDB, puede utilizar el patrón async/
await. Cuando se utiliza esta firma, Lambda ejecuta la función de forma síncrona y espera a que devuelva
una respuesta o a que se agote el tiempo de espera (p. 52) de ejecución.

381
 AWS Lambda Guía para desarrolladores
Contexto

public async Task<Response> ProcessS3ImageResizeAsync(SimpleS3Event input)

{
var response = await [Link](input);
return response;
}

Si utiliza este patrón, debe tener en cuenta algunas consideraciones:

• AWS Lambda no admite métodos async void.

• Si crea una función de Lambda asíncrona sin implementar el operador await, .NET emitirá una
advertencia de compilación y se producirá un comportamiento inesperado. Por ejemplo, algunas
acciones asíncronas se ejecutarán, mientras que otras no. O algunas acciones asíncronas no terminarán
antes de que finalice la ejecución de la función.

public async Task ProcessS3ImageResizeAsync(SimpleS3Event event) // Compiler warning

{
[Link](input);
}

• La función de Lambda puede incluir varias llamadas asíncronas, que pueden invocarse en paralelo.
Puede utilizar los métodos [Link] y [Link] para trabajar con varias tareas. Para
utilizar el método [Link], pase una lista de las operaciones en una matriz al método. En el
ejemplo siguiente, tenga en cuenta que si olvida incluir cualquier operación en la matriz, la llamada
puede volver antes de que finalice su operación.

public async Task DoesNotWaitForAllTasks1()

{
// In Lambda, [Link] goes to CloudWatch Logs.
var task1 = [Link](() => [Link]("Test1"));
var task2 = [Link](() => [Link]("Test2"));
var task3 = [Link](() => [Link]("Test3"));

// Lambda may return before printing "Test2" since we never wait on task2.
await [Link](task1, task3);
}

Para utilizar el método [Link], también se pasa una lista de las operaciones en una matriz al
método. La llamada vuelve tan pronto como finaliza la primera operación, incluso si las demás siguen
ejecutándose.

public async Task DoesNotWaitForAllTasks2()

{
// In Lambda, [Link] goes to CloudWatch Logs.
var task1 = [Link](() => [Link]("Test1"));
var task2 = [Link](() => [Link]("Test2"));
var task3 = [Link](() => [Link]("Test3"));

// Lambda may return before printing all tests since we're only waiting for one to
finish.
await [Link](task1, task2, task3);
}

AWS Lambda Objeto context en C#

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 378). Este objeto
proporciona propiedades con información acerca de la invocación, la función y el entorno de ejecución.

382
 AWS Lambda Guía para desarrolladores
Registro

Propiedades de context

• FunctionName: El nombre de la función de Lambda.

• FunctionVersion: La versión (p. 68) de la función.
• InvokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
Indica si el invocador ha especificado un alias o un número de versión.
• MemoryLimitInMB: La cantidad de memoria que se asigna para la función.
• AwsRequestId: El identificador de la solicitud de invocación.
• LogGroupName: El grupo de registros de la función.
• LogStreamName: El flujo de registro para la instancia de la función.
• RemainingTime (TimeSpan): El número de milisegundos que faltan antes de que se agote el tiempo
de espera.
• Identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• ClientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
aplicación del cliente.
• Logger: el objeto logger (p. 383) para la función.

El siguiente fragmento de código C# muestra una función de controlador sencilla que imprime parte de la
información de contexto.

public async Task Handler(ILambdaContext context)

{
[Link]("Function name: " + [Link]);
[Link]("RemainingTime: " + [Link]);
await [Link]([Link](0.42));
[Link]("RemainingTime after sleep: " + [Link]);
}

AWS Lambda Función de registro en C#

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

Para generar registros desde el código de función, puede utilizar los métodos de la clase Console o
cualquier biblioteca de registro que escriba en stdout o en stderr. El siguiente ejemplo registra el ID de
la solicitud para una invocación.

public class ProductService

{
public async Task<Product> DescribeProduct(DescribeProductRequest request)
{
[Link]("DescribeProduct invoked with Id " + [Link]);
return await [Link]([Link]);
}
}

Lambda también proporciona una clase de registrador en la biblioteca de [Link] . Utilice

el método Log en la clase [Link] para escribir registros.

using [Link];

383
 AWS Lambda Guía para desarrolladores
Registro

public class ProductService

{
public async Task<Product> DescribeProduct(DescribeProductRequest request)
{
[Link]("DescribeProduct invoked with Id " + [Link]);
return await [Link]([Link]);
}
}

También hay una instancia de esta clase disponible en el objeto context (p. 382).

public class ProductService

{
public async Task<Product> DescribeProduct(DescribeProductRequest request,
ILambdaContext context)
{
[Link]("DescribeProduct invoked with Id " + [Link]);
return await [Link]([Link]);
}
}

Example Formato de registro

START RequestId: 29d229ff-xmpl-49d8-8d86-b1f89b06bdc9 Version: $LATEST

END RequestId: 29d229ff-xmpl-49d8-8d86-b1f89b06bdc9
REPORT RequestId: 29d229ff-xmpl-49d8-8d86-b1f89b06bdc9 Duration: 576.36 ms Billed
Duration: 600 ms Memory Size: 512 MB Max Memory Used: 69 MB Init Duration: 205.64 ms
XRAY TraceId: 1-5e34a44f-a125xmpl3603a4cdf526103e SegmentId: 5f41xmpl4b1664d9 Sampled:
true

El tiempo de ejecución de .NET registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 385)
• Mediante la AWS CLI (p. 385)

384
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

• Eliminación de registros (p. 386)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

385
 AWS Lambda Guía para desarrolladores
Eliminación de registros

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

386
 AWS Lambda Guía para desarrolladores
Errores

AWS Lambda Errores de funciones en C#

Cuando se produzca una excepción en una función de Lambda, Lambda le proporcionará información
sobre la excepción. Las excepciones pueden producirse en dos lugares distintos:

• Inicialización (cuando Lambda carga el código, valida la cadena de controlador y crea una instancia de la
clase, si no es estática).
• La invocación de la función de Lambda.

La información serializada sobre la excepción se devuelve como la carga de un objeto JSON modelado, y
se registra en los logs de CloudWatch.

En la fase de inicialización, pueden producirse excepciones para cadenas de controlador no válidas,

métodos o tipos que no cumplan las reglas (consulte Restricciones del controlador de funciones de
Lambda (p. 381)) o cualquier otro método de validación (como olvidar el atributo serializador y utilizar
POCO como tipo de entrada o salida). Estas excepciones son de tipo LambdaException. Por ejemplo:

{
"errorType": "LambdaException",
"errorMessage": "Invalid lambda function handler: '[Link]
The valid format is 'ASSEMBLY::TYPE::METHOD'."
}

Si el constructor genera una excepción, el error también es del tipo LambdaException, pero la excepción
generada durante la construcción se proporciona en la propiedad cause, que es un objeto de excepción
modelado:

{
"errorType": "LambdaException",
"errorMessage": "An exception was thrown when the constructor for type
'[Link]'
was invoked. Check inner exception for more details.",
"cause": {
"errorType": "TargetInvocationException",
"errorMessage": "Exception has been thrown by the target of an invocation.",
"stackTrace": [
"at [Link](RuntimeType type, Boolean publicOnly,
Boolean noCheck, Boolean&canBeCached,
RuntimeMethodHandleInternal&ctor, Boolean& bNeedSecurityCheck)",
"at [Link](Boolean publicOnly, Boolean skipCheckThis,
Boolean fillCache, StackCrawlMark& stackMark)",
"at [Link](Type type, Boolean nonPublic)",
"at [Link](Type type)"
],
"cause": {
"errorType": "ArithmeticException",
"errorMessage": "Sorry, 2 + 2 = 5",
"stackTrace": [
"at [Link]..ctor()"
]
}
}
}

Como muestra el ejemplo, las excepciones internas siempre se conservan (como la propiedad cause) y
pueden anidarse profundamente.

Las excepciones también pueden producirse durante la invocación. En este caso, se conserva el tipo de la
excepción y esta se devuelve directamente como carga y en los logs de CloudWatch. Por ejemplo:

387
 AWS Lambda Guía para desarrolladores
Errores

{
"errorType": "AggregateException",
"errorMessage": "One or more errors occurred. (An unknown web exception occurred!)",
"stackTrace": [
"at [Link](Boolean
includeTaskCanceledExceptions)",
"at [Link]`[Link](Boolean waitCompletionNotification)",
"at lambda_method(Closure , Stream , Stream , ContextInfo )"
],
"cause": {
"errorType": "UnknownWebException",
"errorMessage": "An unknown web exception occurred!",
"stackTrace": [
"at [Link].<GetUriResponse>d__1.MoveNext()",
"--- End of stack trace from previous location where exception was thrown ---",
"at [Link](Task task)",
"at
[Link](Task
task)",
"at [Link]`[Link]()",
"at [Link].<CheckWebsiteStatus>d__0.MoveNext()"
],
"cause": {
"errorType": "WebException",
"errorMessage": "An error occurred while sending the request. SSL peer certificate or
SSH remote key was not OK",
"stackTrace": [
"at [Link](IAsyncResult asyncResult)",
"at [Link]`[Link](IAsyncResult iar,
Func`2 endFunction, Action`1 endAction, Task`1 promise, Boolean requiresSynchronization)",
"--- End of stack trace from previous location where exception was thrown ---",
"at [Link](Task task)",
"at
[Link](Task
task)",
"at [Link]`[Link]()",
"at [Link].<GetUriResponse>d__1.MoveNext()"
],
"cause": {
"errorType": "HttpRequestException",
"errorMessage": "An error occurred while sending the request.",
"stackTrace": [
"at [Link](Task task)",
"at
[Link](Task
task)",
"at [Link].<FinishSendAsync>d__58.MoveNext()",
"--- End of stack trace from previous location where exception was thrown ---",
"at [Link](Task task)",
"at
[Link](Task
task)",
"at [Link].<SendRequest>d__63.MoveNext()",
"--- End of stack trace from previous location where exception was thrown ---",
"at [Link](Task task)",
"at
[Link](Task
task)",
"at [Link](IAsyncResult asyncResult)"
],
"cause": {
"errorType": "CurlException",
"errorMessage": "SSL peer certificate or SSH remote key was not OK",
"stackTrace": [
"at [Link](CURLcode error)",

388
 AWS Lambda Guía para desarrolladores
Errores

"at
[Link](StrongToWeakReference`1 easyWrapper,
CURLcode messageResult)"
]
}
}
}
}
}

El método con el que se comunica la información del error depende del tipo de invocación:

• Tipo de invocación RequestResponse (es decir, ejecución síncrona): en este caso, se obtiene el
mensaje de error.

Por ejemplo, si invoca una función de Lambda utilizando la consola de Lambda, RequestResponse
siempre es el tipo de invocación, y la consola muestra la información de error devuelta por AWS Lambda
en la sección Execution result (Resultado de ejecución) de la consola.
• Tipo de invocación Event (es decir, ejecución asíncrona): en este caso, AWS Lambda no devuelve
nada. En su lugar, registra la información de error en las métricas de CloudWatch Logs y CloudWatch.

En función del origen de eventos, AWS Lambda puede volver a intentar la ejecución de la función
de Lambda que ha fallado. Para obtener más información, consulte Control de errores y reintentos
automáticos en AWS Lambda (p. 107).

389
 AWS Lambda Guía para desarrolladores
Entorno de desarrollo

Creación de funciones de Lambda

con PowerShell
En las siguientes secciones se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en PowerShell.

Runtimes de .NET

Nombre Identificador Lenguajes Sistema operativo

.NET Core 2.1 dotnetcore2.1 C# Amazon Linux

Powershell Core 6.0

Tenga en cuenta que las funciones Lambda en PowerShell requieren PowerShell Core 6.0. Windows
PowerShell no es compatible.

Antes de comenzar, primero debe configurar un entorno de desarrollo de PowerShell. Para obtener
instrucciones al respecto, consulte Configuración del entorno de desarrollo de PowerShell (p. 390).

Para obtener más información sobre cómo utilizar el módulo AWSLambdaPSCore para descargar
proyectos de muestra de PowerShell a partir de plantillas, cómo crear paquetes de implementación de
PowerShell y cómo implementar funciones de PowerShell en la nube de AWS, consulte AWS Lambda
Paquete de implementación en PowerShell (p. 391).

Temas
• Configuración del entorno de desarrollo de PowerShell (p. 390)
• AWS Lambda Paquete de implementación en PowerShell (p. 391)
• AWS Lambda Controlador de funciones en PowerShell (p. 392)
• AWS Lambda Objeto de Contexto en PowerShell (p. 393)
• AWS Lambda Registro de funciones en PowerShell (p. 394)
• AWS Lambda errores de función en PoweShell. (p. 397)

Configuración del entorno de desarrollo de

PowerShell
Para configurar su entorno de desarrollo para escribir scripts de PowerShell, haga lo siguiente:

1. Instale la versión correcta de PowerShell. La compatibilidad de Lambda para PowerShell se basa

en la versión PowerShell Core 6.0 multiplataforma. Esto significa que puede desarrollar funciones
de Lambda de PowerShell en Windows, Linux o Mac. Si no dispone de esta versión de PowerShell
instalada, puede encontrar instrucciones en Instalación de PowerShell Core.
2. Instale el SDK de .NET Core 2.1. Dado que PowerShell Core se basa en .NET Core, la compatibilidad
de Lambda con PowerShell utiliza el mismo tiempo de ejecución de Lambda de .NET Core 2.1 tanto
para las funciones de Lambda de .NET Core como para las de PowerShell. Los nuevos cmdlets de
publicación de Lambda de PowerShell utilizan el SDK de .NET Core 2.1 para crear el paquete de
implementación de Lambda. El SDK de .NET Core 2.1 está disponible en Descargas de .NET en el
sitio web de Microsoft. Asegúrese de instalar el SDK, no la instalación en tiempo de ejecución.

390
 AWS Lambda Guía para desarrolladores
Paquete de implementación

3. Instale el módulo AWSLambdaPSCore. Puede realizar esta instalación desde la PowerShell Gallery, o
bien utilizando el siguiente comando de shell PowerShell Core:

Install-Module AWSLambdaPSCore -Scope CurrentUser

AWS Lambda Paquete de implementación en

PowerShell
Un paquete de implementación de Lambda para PowerShell es un archivo ZIP que contiene su script
de PowerShell, los módulos de PowerShell necesarios para su script de PowerShell y los ensamblados
necesarios para alojar PowerShell Core.

El módulo AWSLambdaPSCore tiene los siguientes nuevos cmdlets para ayudarle a crear y publicar las
funciones de Lambda para PowerShell.

AWSLambdaPSCore Cmdlets

• Get-AWSPowerShellLambdaTemplate: devuelve una lista de plantillas de introducción.

• New-AWSPowerShellLambda: crea un script de PowerShell inicial basado en una plantilla.
• Publish-AWSPowerShellLambda: publica un script de PowerShell determinado en Lambda.
• New-Lambda AWSPowerShellLambdaPackage: crea un paquete de implementación Lambda que se
puede utilizar en un sistema de CI/CD para la implementación.

Para que le resulte más fácil empezar a escribir e invocar un script de PowerShell con Lambda, puede
utilizar el cmdlet New-AWSPowerShellLambda para crear un script de inicio basado en una plantilla.
Puede utilizar el cmdlet Publish-AWSPowerShellLambda para implementar su script en AWS Lambda.
A continuación, puede probar el script ya sea a través de la línea de comandos o de la consola.

Para crear un nuevo script de PowerShell, cargarlo y probarlo, siga este procedimiento:

1. Ejecute el siguiente comando para ver la lista de plantillas disponibles:

PS C:\> Get-AWSPowerShellLambdaTemplate

Template Description
-------- -----------
Basic Bare bones script
CodeCommitTrigger Script to process AWS CodeCommit Triggers
...

2. Ejecute el siguiente comando para crear un script de muestra basado en la plantilla Basic:

New-AWSPowerShellLambda -ScriptName MyFirstPSScript -Template Basic

Se creará un nuevo archivo denominado MyFirstPSScript.ps1 en un nuevo subdirectorio del

directorio actual. El nombre del directorio se basa en el parámetro -ScriptName. Puede utilizar el
parámetro -Directory para elegir un directorio alternativo.

Puede ver que el nuevo archivo tiene el siguiente contenido:

# PowerShell script file to be executed as a AWS Lambda function.

#
# When executing in Lambda the following variables will be predefined.
# $LambdaInput - A PSObject that contains the Lambda function input data.

391
 AWS Lambda Guía para desarrolladores
Controlador

# $LambdaContext - An [Link] object that contains

information about the currently running Lambda environment.
#
# The last item in the PowerShell pipeline will be returned as the result of the Lambda
function.
#
# To include PowerShell modules with your Lambda function, like the
[Link] module, add a "#Requires" statement
# indicating the module and version.

#Requires -Modules @{ModuleName='[Link]';ModuleVersion='[Link]'}

# Uncomment to send the input to CloudWatch Logs

# Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)

3. Para ver cómo se envían los mensajes de registro desde su secuencia de comandos de PowerShell a
CloudWatch Logs, anule el comentario de la línea Write-Host del script de muestra.

Para demostrar cómo puede devolver los datos de sus funciones de Lambda, añada una nueva línea
al final del script con $PSVersionTable. Esto añadirá $PSVersionTable a la canalización de
PowerShell. Una vez que el script de PowerShell se ha completado, el último objeto en la canalización
de PowerShell son los datos de devolución de la función de Lambda. $PSVersionTable es una
variable global de PowerShell que también proporciona información sobre el entorno en ejecución.

Después de realizar estos cambios, las dos últimas líneas del script de muestra tienen un aspecto
similar al siguiente:

Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)

$PSVersionTable

4. Después de editar el archivo MyFirstPSScript.ps1, cambie el directorio a la ubicación del script.

Después, ejecute el siguiente comando para publicar el script en AWS Lambda:

Publish-AWSPowerShellLambda -ScriptPath .\MyFirstPSScript.ps1 -Name MyFirstPSScript -

Region us-east-2

Tenga en cuenta que el parámetro -Name especifica el nombre de la función de Lambda, que aparece
en la consola de Lambda. Puede utilizar esta función para invocar manualmente a su script.
5. Invoque su función con el comando invoke de la CLI de AWS.

> aws lambda invoke --function-name MyFirstPSScript out

AWS Lambda Controlador de funciones en

PowerShell
Cuando se invoca una función de Lambda, el controlador de Lambda invoca al script de PowerShell.

Cuando el script de PowerShell se invoca, se predefinen las siguientes variables:

• $ LambdaInput: un PSObject que contiene la entrada al controlador. Esta entrada puede estar
formada por datos de eventos (publicados por un origen de eventos) o por una entrada personalizada
que proporcione, como una cadena o cualquier objeto de datos personalizado.
• $LambdaContext: un objeto [Link] que puede utilizar para obtener
acceso a información sobre la ejecución actual, como el nombre de la función actual, el límite de
memoria, el tiempo de ejecución restante y el registro.

392
 AWS Lambda Guía para desarrolladores
Devolución de datos

Por ejemplo, fíjese en el siguiente código de ejemplo de PowerShell.

#Requires -Modules @{ModuleName='[Link]';ModuleVersion='[Link]'}

Write-Host 'Function Name:' $[Link]

Este script devuelve la propiedad FunctionName que obtiene de la variable $LambdaContext.

Note

Es necesario que utilice la instrucción #Requires dentro de sus scripts de PowerShell para
indicar los módulos de los que dependen los scripts. Esta instrucción realiza dos tareas
importantes. 1) Comunica a otros desarrolladores los módulos que utiliza el script; y 2) identifica
los módulos dependientes que necesitan las herramientas de AWS PowerShell para incluir en el
paquete con el script, como parte de la implementación. Para obtener más información sobre la
instrucción #Requires en PowerShell, consulte About Requires. Para obtener más información
sobre los paquetes de implementación de PowerShell, consulte AWS Lambda Paquete de
implementación en PowerShell (p. 391).
Si su función de Lambda para PowerShell utiliza los cmdlets de AWS PowerShell,
asegúrese de establecer una instrucción #Requires que haga referencia al módulo
[Link], que admite PowerShell Core y no el módulo AWSPowerShell, que
solo admite Windows PowerShell. Además, asegúrese de utilizar la versión [Link] o posterior
de [Link], que optimiza el proceso de importación del cmdlet. Si utiliza una
versión anterior, experimentará unos arranques en frío más largos. Para obtener más información,
consulte Herramientas de AWS para PowerShell.

Devolución de datos
Algunas invocaciones Lambda están destinadas a devolver los datos a su intermediario. Por ejemplo, si
una invocación se hizo en respuesta a una solicitud web procedente de API Gateway, entonces nuestra
función de Lambda debe devolver la respuesta. Para PowerShell Lambda, el último objeto que se añade a
la canalización de PowerShell son los datos de devolución de la invocación de Lambda. Si el objeto es una
cadena, los datos se devuelven tal cual. De lo contrario, el objeto se convierte en JSON mediante el uso
del cmdlet ConvertTo-Json.

Por ejemplo, observe la siguiente instrucción de PowerShell, que añade $PSVersionTable a la

canalización de PowerShell:

$PSVersionTable

Una vez que el script de PowerShell ha finalizado, el último objeto en la canalización de PowerShell son los
datos de devolución de la función de Lambda. $PSVersionTable es una variable global de PowerShell
que también proporciona información sobre el entorno en ejecución.

AWS Lambda Objeto de Contexto en PowerShell

Cuando Lambda ejecuta su función, pasa información de context haciendo que una variable
$LambdaContext esté disponible para el controlador (p. 392). Esta variable proporciona métodos y
propiedades con información acerca de la invocación, la función y el entorno de ejecución.

Propiedades de context

• FunctionName: El nombre de la función de Lambda.

• FunctionVersion: La versión (p. 68) de la función.
• InvokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
Indica si el invocador ha especificado un alias o un número de versión.

393
 AWS Lambda Guía para desarrolladores
Registro

• MemoryLimitInMB: La cantidad de memoria que se asigna para la función.

• AwsRequestId: El identificador de la solicitud de invocación.
• LogGroupName: El grupo de registros de la función.
• LogStreamName: El flujo de registro para la instancia de la función.
• RemainingTime: El número de milisegundos que faltan antes de que se agote el tiempo de espera.
• Identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• ClientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
aplicación del cliente.
• Logger: el objeto logger (p. 394) para la función.

El siguiente fragmento de código PowerShell muestra una función de controlador sencilla que imprime
parte de la información de contexto.

#Requires -Modules @{ModuleName='[Link]';ModuleVersion='[Link]'}

Write-Host 'Function name:' $[Link]
Write-Host 'Remaining milliseconds:' $[Link]
Write-Host 'Log group name:' $[Link]
Write-Host 'Log stream name:' $[Link]

AWS Lambda Registro de funciones en PowerShell

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.

Para generar registros desde el código de su función, puede usar cmdlets en [Link]
o en cualquier módulo de registro que escriba en stdout o en stderr. En el siguiente ejemplo se utiliza
Write-Host para registrar las variables de entorno.

Example function.ps1

#Requires -Modules @{ModuleName='[Link]';ModuleVersion='[Link]'}

$var = (Get-ChildItem env:*).GetEnumerator() | Sort-Object Name
$out = "`n"
Foreach ($v in $var) {$out = $out + "{0} : {1}`n" -f $[Link], $[Link]}
Write-Host ( $out )

Example Formato de registro

START RequestId: d50fc4d4-xmpl-4b55-8225-af0c43bb27d2 Version: $LATEST

Importing module ./Modules/[Link]/[Link]/[Link].psd1
[Information] - Region: us-east-2
[Information] - Function name: my-function
END RequestId: d50fc4d4-xmpl-4b55-8225-af0c43bb27d2
REPORT RequestId: d50fc4d4-xmpl-4b55-8225-af0c43bb27d2 Duration: 601.73 ms Billed
Duration: 700 ms Memory Size: 512 MB Max Memory Used: 365 MB Init Duration: 5994.31 ms
XRAY TraceId: 1-5e34a46a-591fxmpl7a412745094b2b7a SegmentId: 4988xmpl190a003a Sampled:
true

El tiempo de ejecución de .NET registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

394
 AWS Lambda Guía para desarrolladores
Visualización de registros en la
Consola de administración de AWS

Registro de informes

• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastro de AWS X-Ray (p. 404).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.

Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.

Secciones
• Visualización de registros en la Consola de administración de AWS (p. 395)
• Mediante la AWS CLI (p. 395)
• Eliminación de registros (p. 397)

Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.

Para ver los registros de la función de Lambda

1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.

Cada flujo de registro se corresponde con una instancia de su función (p. 120). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y registros de seguimiento con X-Ray,
consulte Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 141).

Mediante la AWS CLI

Para obtener los registros de una invocación desde la línea de comandos, utilice la opción --log-type.
La respuesta incluye un campo LogResult que contiene hasta 4 KB de registros con codificación base64
a partir de la invocación.

$ aws lambda invoke --function-name my-function out --log-type Tail

395
 AWS Lambda Guía para desarrolladores
Mediante la AWS CLI

{
"StatusCode": 200,
"LogResult":
"U1RBUlQgUmVxdWVzdElkOiA4N2QwNDRiOC1mMTU0LTExZTgtOGNkYS0yOTc0YzVlNGZiMjEgVmVyc2lvb...",
"ExecutedVersion": "$LATEST"
}

Puede utilizar la utilidad base64 para descodificar los registros.

$ aws lambda invoke --function-name my-function out --log-type Tail \

--query 'LogResult' --output text | base64 -d
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST
"AWS_SESSION_TOKEN": "AgoJb3JpZ2luX2VjELj...", "_X_AMZN_TRACE_ID": "Root=1-5d02e5ca-
f5792818b6fe8368e5b51d50;Parent=191db58857df8395;Sampled=0"",ask/lib:/opt/lib",
END RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8
REPORT RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Duration: 79.67 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 73 MB

La utilidad base64 está disponible en Linux, MacOS y Ubuntu en Windows. Para el sistema operativo
macOS, el comando es base64 -D.

Para obtener eventos de registro completos desde la línea de comandos, puede incluir el nombre del
flujo de registros en la salida de la función, como se muestra en el ejemplo anterior. El siguiente script de
ejemplo invoca una función denominada my-function y descarga los últimos cinco eventos de registro.

Example Script [Link]

Este ejemplo requiere que my-function devuelva un ID de flujo de registros.

#!/bin/bash
aws lambda invoke --function-name my-function --payload '{"key": "value"}' out
sed -i'' -e 's/"//g' out
sleep 15
aws logs get-log-events --log-group-name /aws/lambda/my-function --log-stream-name $(cat
out) --limit 5

El script utiliza sed para eliminar las comillas del archivo de salida y permanece inactivo durante
15 segundos para dar tiempo a que los registros estén disponibles. La salida incluye la respuesta de
Lambda y la salida del comando get-log-events.

$ ./[Link]
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
{
"events": [
{
"timestamp": 1559763003171,
"message": "START RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf Version:
$LATEST\n",
"ingestionTime": 1559763003309
},
{
"timestamp": 1559763003173,
"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tENVIRONMENT VARIABLES\r{\r \"AWS_LAMBDA_FUNCTION_VERSION\": \"$LATEST\",\r ...",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003173,

396
 AWS Lambda Guía para desarrolladores
Eliminación de registros

"message": "2019-06-05T19:30:03.173Z\t4ce9340a-b765-490f-ad8a-02ab3415e2bf
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
"ingestionTime": 1559763018353
},
{
"timestamp": 1559763003218,
"message": "REPORT RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\tDuration:
26.73 ms\tBilled Duration: 100 ms \tMemory Size: 128 MB\tMax Memory Used: 75 MB\t\n",
"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Eliminación de registros
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.

AWS Lambda errores de función en PoweShell.

Si su función de Lambda tiene un error al terminar, AWS Lambda reconoce el error, serializa la información
de error en JSON y lo devuelve.

Considere la siguiente instrucción de ejemplo de script de PowerShell:

throw 'The Account is not found'

Al invocar esta función de Lambda, se genera un error de terminación y AWS Lambda devuelve el
siguiente mensaje de error:

{
"errorMessage": "The Account is not found",
"errorType": "RuntimeException"
}

Tenga en cuenta que errorType es RuntimeException, que es la excepción predeterminada generada

por PowerShell. Puede utilizar los tipos de error personalizados generando el error de la siguiente forma:

throw @{'Exception'='AccountNotFound';'Message'='The Account is not found'}

El mensaje de error se serializa con errorType establecido en AccountNotFound:

{
"errorMessage": "The Account is not found",
"errorType": "AccountNotFound"
}

397
 AWS Lambda Guía para desarrolladores
Errores

Si no necesita un mensaje de error, puede generar una cadena con el formato de un código de error. El
formato de código de error requiere que la cadena empiece con un carácter y solo contenga letras y dígitos
a continuación, sin espacios ni símbolos.

Por ejemplo, si su función de Lambda contiene lo siguiente:

throw 'AccountNotFound'

El error se serializa como se indica a continuación:

{
"errorMessage": "AccountNotFound",
"errorType": "AccountNotFound"
}

398
 AWS Lambda Guía para desarrolladores

Monitorización y solución de
problemas de aplicaciones basadas
en Lambda
AWS Lambda monitoriza automáticamente funciones Lambda en su nombre e informa sobre las métricas
a través de Amazon CloudWatch. Para ayudarle a monitorizar el código mientras se ejecuta, Lambda
controla automáticamente el número de solicitudes, la duración de la ejecución por solicitud y el número de
solicitudes que generan un error. También publica las métricas de CloudWatch asociadas. Puede utilizar
estas métricas para configurar alarmas personalizadas de CloudWatch. Para obtener más información
sobre CloudWatch, consulte la Guía del usuario de Amazon CloudWatch.

Puede ver las tasas de solicitudes y las tasas de errores de cada una de sus funciones Lambda utilizando
la consola de AWS Lambda, la consola de CloudWatch y otros recursos de AWS. En los siguientes temas
se describen las métricas de CloudWatch para las funciones de Lambda y cómo acceder a ellas.

• Monitorización de funciones en la consola de AWS Lambda (p. 400)

• Trabajar con métricas de función de AWS Lambda (p. 400)

Puede introducir instrucciones de registro en el código para ayudarle a validar que el código está
funcionando según lo previsto. Lambda se integra automáticamente con Amazon CloudWatch Logs.
Inserta todos los registros de su código en un grupo de CloudWatch Logs que está asociado con una
función de Lambda (/aws/lambda/<nombre de la función>). Para obtener más información sobre
los grupos de registro y el acceso a ellos a través de la consola de CloudWatch, consulte Trabajar con
grupos y secuencias de registro en la Guía del usuario de Amazon CloudWatch Logs. Para obtener más
información acerca de cómo acceder a las entradas de registro de CloudWatch, consulte Acceso a los
registros de Amazon CloudWatch para AWS Lambda (p. 403).
Note

Si el código de la función de Lambda se está ejecutando, pero no se genera ningún dato de

registro después de varios minutos, podría significar que el rol de ejecución de la función de
Lambda no ha concedido permisos para escribir datos de registro en CloudWatch Logs. Para
obtener información acerca de cómo asegurarse de que se ha configurado correctamente el rol de
ejecución para conceder estos permisos, consulte Rol de ejecución de AWS Lambda (p. 32).

Cada uno de los servicios de monitorización proporciona una capa gratuita. Si la aplicación supera los
límites de capa gratuita, los precios se basan en el uso. Para obtener más información, consulte Precios de
CloudWatch y Precios de X-Ray. Tenga en cuenta también que las tasas de almacenamiento estándar se
aplican a los registros de CloudWatch almacenados por el servicio Lambda.

Los servicios de monitorización siguen estos modelos de uso:

• AWS Lambda informa de métricas y registros a CloudWatch cada vez que se ejecuta la función de
Lambda.
• CloudWatch Logs Insights se ejecuta cuando consulta la página Monitoring (Monitorización) de su
función de Lambda.

399
 AWS Lambda Guía para desarrolladores
Consola de administración

• X-Ray comienza a registrar rastreos cuando se habilita X-Ray para una función o cuando un servicio
ascendente habilita X-Ray.

Monitorización de funciones en la consola de AWS

Lambda
AWS Lambda monitoriza funciones en su nombre y envía métricas a Amazon CloudWatch. Las métricas
incluyen el total de solicitudes, la duración y las tasas de errores. La consola de Lambda crea gráficos para
estas métricas y las muestra en la página Monitoring (Monitorización) de cada función.

Para obtener acceso a la consola de monitorización

1. Abra la consola de Lambda.

2. Abra la página Functions (Funciones) en la consola de Lambda.
3. Elija Monitoring (Monitorización).

La consola ofrece los gráficos siguientes.

Gráficos de monitorización de Lambda

• Invocations (Invocaciones): el número de veces que se invocó la función en cada período de 5 minutos.
• Duration (Duración): los tiempos promedio, mínimo y máximo de ejecución.
• Error count and success rate (%) (Número de errores y tasa de éxito (%)): el número de errores y el
porcentaje de ejecuciones completadas sin errores.
• Throttles (Limitaciones): el número de veces que se produjo un error en la ejecución debido a los límites
de simultaneidad.
• IteratorAge: en los orígenes de eventos de flujo, la antigüedad del último elemento del lote cuando
Lambda lo recibe e invoca la función.
• Errores de entrega asincrónicos: Número de errores que se produjeron cuando Lambda intentó escribir
en una cola de mensajes fallidos o destino.
• Ejecuciones simultáneas: Número de instancias de función que están procesando eventos.

Para ver la definición de un gráfico en CloudWatch, elija View in metrics (Ver en métricas) en el menú de
la parte superior derecha del gráfico. Para obtener más información acerca de las métricas que Lambda
registra, consulte Trabajar con métricas de función de AWS Lambda (p. 400).

La consola también muestra los informes de CloudWatch Logs Insights compilados a partir de información
en sus registros de función. Puede añadir estos informes a un panel personalizado en la consola de
CloudWatch Logs. Utilice las consultas como punto de partida para sus propios informes.

Para ver una consulta, elija View en CloudWatch Logs Insights (Ver en CloudWatch Logs Insights) en el
menú de la parte superior derecha del informe.

Trabajar con métricas de función de AWS Lambda

Cuando la función termina de procesar un evento, Lambda envía métricas sobre la invocación a Amazon
CloudWatch. Puede crear gráficos y paneles con estas métricas en la consola de CloudWatch y establecer
alarmas para responder a cambios en el uso, el rendimiento o las tasas de error. Utilice las dimensiones
para filtrar y clasificar métricas de funciones por nombre de función, alias o versión.

400
 AWS Lambda Guía para desarrolladores
Uso de métricas de invocación

Para ver métricas en la consola de CloudWatch

1. Abra la página Metrics (métricas) de la consola de Amazon CloudWatch (espacio de nombres AWS/
Lambda).
2. Elija una dimensión.

• Por nombre de función (FunctionName): Ver métricas agregadas de todas las versiones y alias de
una función.
• Por recurso (Resource): Ver las métricas de una versión o el alias de una función.
• Por versión ejecutada (ExecutedVersion): Ver métricas para una combinación de alias y versión.
Utilice la dimensión ExecutedVersion para comparar las tasas de error de dos versiones de una
función que son objetivos de un alias ponderado (p. 70).
• En todas las funciones (ninguna): Ver métricas agregadas de todas las funciones de la región de
AWS actual.
3. Elija métricas para agregarlas al gráfico.

De forma predeterminada, los gráficos utilizan la estadística Sum para todas las métricas. Para elegir una
estadística diferente y personalizar el gráfico, utilice las opciones de la pestaña Métricas Gráficas .

La marca temporal de una métrica refleja cuándo se invocó la función. Dependiendo de la duración de la
ejecución, esto puede ser varios minutos antes de la emisión de la métrica. Si, por ejemplo, su función
tiene un tiempo de espera de 10 minutos, busque más de 10 minutos en el pasado para obtener métricas
precisas.

Para obtener más información acerca de CloudWatch, consulte la Guía del usuario de Amazon
CloudWatch.

Secciones
• Uso de métricas de invocación (p. 401)
• Uso de métricas de desempeño (p. 402)
• Uso de métricas de simultaneidad (p. 402)

Uso de métricas de invocación

Las métricas de invocación son indicadores binarios del resultado de una invocación. Por ejemplo, si la
función devuelve un error, Lambda envía la métrica Errors con un valor de 1. Para obtener un recuento
del número de errores de función que se produjeron cada minuto, vea la suma de la métrica Errors con
un período de un minuto.

Debe ver las siguientes métricas con la estadística Sum.

Métricas de invocación

• Invocations: El número de veces que se ejecuta el código de función, incluidas las ejecuciones
exitosas y las ejecuciones que dan lugar a un error de función. Las invocaciones no se registran si la
solicitud de invocación se limita o da lugar a un error de invocación (p. 529). Esto equivale al número
de solicitudes facturadas.
• Errors: El número de invocaciones que dan lugar a un error de función. Los errores de función
incluyen excepciones lanzadas por su código y excepciones lanzadas por el tiempo de ejecución de
Lambda. El motor de ejecución devuelve errores para problemas como tiempos de espera y errores de
configuración. Para calcular la tasa de error, divida el valor de Errors por el valor de Invocations.
• DeadLetterErrors: Para la invocación asíncrona (p. 89), el número de veces que Lambda intenta
enviar un evento a una cola de mensajes fallidos pero falla. Pueden producirse errores de mensaje
fallido debido a errores de permisos, recursos mal configurados o límites de tamaño.

401
 AWS Lambda Guía para desarrolladores
Uso de métricas de desempeño

• DestinationDeliveryFailures: Para la invocación asíncrona, el número de veces que Lambda

intenta enviar un evento a un destino (p. 26) pero falla. Pueden producirse errores de entrega debido a
errores de permisos, recursos mal configurados o límites de tamaño.
• Throttles: El número de solicitudes de invocación que se han limitado. Cuando todas las instancias
de función están procesando solicitudes y no hay concurrencia disponible para escalar, Lambda rechaza
solicitudes adicionales con TooManyRequestsException (p. 529). Las solicitudes aceleradas y otros
errores de invocación no cuentan como Invocations o Errors.
• ProvisionedConcurrencyInvocations: El número de veces que su código de función se ejecuta
en concurrencia aprovisionada (p. 59).
• ProvisionedConcurrencySpilloverInvocations: El número de veces que su código de función
se ejecuta en concurrencia estándar cuando toda concurrencia aprovisionada está en uso.

Uso de métricas de desempeño

Las métricas de desempeño proporcionan detalles de rendimiento sobre una única invocación. Por
ejemplo, la métrica Duration indica la cantidad de tiempo en milisegundos que la función gasta
procesando un evento. Para obtener una idea de la rapidez con la que su función procesa eventos,
consulte estas métricas con la estadística Average o Maximum.

Métricas de desempeño

• Duration: La cantidad de tiempo que el código de función pasa procesando un evento. Para el primer
evento procesado por una instancia de su función, esto incluye el tiempo de inicialización (p. 19). La
duración facturada de una invocación es el valor de Duration redondeado hacia arriba a los 100
milisegundos más cercanos.
• IteratorAge: Para las asignaciones de origen de eventos (p. 97) que leen desde secuencias, la
antigüedad del último registro del evento. La antigüedad es la cantidad de tiempo entre cuando la
secuencia recibe el registro y cuando la asignación de origen de eventos envía el evento a la función.

Duration también admite estadísticas percentiles. Utilice percentiles para excluir valores atípicos que
sesgan las estadísticas medias y máximas. Por ejemplo, la estadística P95 muestra la duración máxima
del 95 por ciento de las ejecuciones, excluyendo el 5 por ciento más lento.

Uso de métricas de simultaneidad

Lambda informa de las métricas de concurrencia como un recuento agregado del número de instancias
que procesan eventos en una función, versión, alias o región de AWS. Para ver lo cerca que está de
alcanzar los límites de concurrencia, consulte estas métricas con la estadística Max.

Métricas de simultaneidad

• ConcurrentExecutions: Número de instancias de función que están procesando eventos. Si este

número alcanza el límite de ejecuciones simultáneas (p. 30) para la región o el límite de concurrencia
reservado (p. 59) que configuró en la función, se limitarán las solicitudes de invocación adicionales.
• ProvisionedConcurrentExecutions: El número de instancias de función que están procesando
eventos en concurrencia aprovisionada (p. 59). Para cada invocación de un alias o versión con
simultaneidad aprovisionada, Lambda emite el recuento actual.
• ProvisionedConcurrencyUtilization: Para una versión o alias, el valor de
ProvisionedConcurrentExecutions dividido entre la cantidad total de concurrencia aprovisionada
asignada. Por ejemplo, .5 indica que el 50 por ciento de la simultaneidad aprovisionada asignada está
en uso.
• UnreservedConcurrentExecutions: Para una región de AWS, el número de eventos que están
procesando funciones que no tienen concurrencia reservada.

402
 AWS Lambda Guía para desarrolladores
Registros de CloudWatch

Acceso a los registros de Amazon CloudWatch para

AWS Lambda
AWS Lambda monitoriza automáticamente las funciones de Lambda en su nombre, e informa sobre las
métricas a través de Amazon CloudWatch. Para ayudarle a solucionar problemas relacionados con los
errores de una función, Lambda registra todas las solicitudes gestionadas por la función, y almacena
automáticamente los registros generados por el código a través de Amazon CloudWatch Logs.

Puede introducir instrucciones de registro en el código comprobar que el código está funcionando según lo
previsto. Lambda se integra automáticamente con CloudWatch Logs y envía todos los registros generados
por el código a un grupo de CloudWatch Logs asociado a una función de Lambda, denominada /aws/
lambda/<nombre de la función>. Para obtener más información acerca de los grupos de registros y
cómo acceder a ellos a través de la consola de CloudWatch, consulte Monitoring System, Application, and
Custom Log Files en la Guía del usuario de Amazon CloudWatch.

Puede ver los registros de Lambda mediante la consola de Lambda, la consola de CloudWatch, la AWS
CLI o la API de CloudWatch. El siguiente procedimiento muestra cómo ver los registros utilizando la
consola de Lambda.
Note

No se aplican cargos adicionales por utilizar los registros de Lambda; no obstante, sí se aplican
los cargos estándar de CloudWatch Logs. Para obtener más información, consulte los precios de
CloudWatch.

Para ver los registro mediante la consola de Lambda

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. Elija Monitoring (Monitorización).

403
 AWS Lambda Guía para desarrolladores
Uso de AWS X-Ray

Se muestra una representación gráfica de las métricas de la función de Lambda.

4. Elija View logs in CloudWatch (Ver registros en CloudWatch).

Lambda utiliza los permisos de la función para cargar los registros en CloudWatch Logs. Si no ve registros
en la consola, compruebe los permisos del rol de ejecución (p. 32).

Uso de AWS X-Ray

Puede utilizar AWS X-Ray para visualizar los componentes de la aplicación, identificar cuellos de botella
de rendimiento y solucionar problemas de solicitudes que dieron lugar a un error. Sus funciones Lambda
envían datos de rastreo a X-Ray y X-Ray procesa los datos para generar un mapa de servicio y resúmenes
de rastreo en los que se puede buscar.

Si ha habilitado el rastreo de X-Ray en un servicio que invoca su función, Lambda envía rastreos a X-
Ray automáticamente. El servicio ascendente, como Amazon API Gateway, o una aplicación alojada en
Amazon EC2 que está instrumentada con el SDK de X-Ray, muestra las solicitudes entrantes y agrega un
encabezado de rastreo que indica Lambda que envíe rastreos o no. Para obtener una lista completa de
los servicios que admiten instrumentación activa, consulte Servicios de AWS admitidos en la Guía para
desarrolladores de AWS X-Ray.

Para rastrear solicitudes que no tienen un encabezado de rastreo, habilite el rastreo activo en la
configuración de la función.

Puede habilitar el rastreo en la configuración de la función.

404
 AWS Lambda Guía para desarrolladores
Rastreo de aplicaciones basadas
en Lambda con AWS X-Ray

Para habilitar el rastreo activo

1. Abra la página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En AWS X-Ray, elija Active tracing (Rastreo activo).
4. Elija Save (Guardar).

Su función necesita permiso para cargar datos de rastreo en X-Ray. Cuando habilita el rastreo activo en la
Lambda consola, Lambda agrega los permisos necesarios al rol de ejecución (p. 32) de la función. De lo
contrario, agregue la política AWSXRayDaemonWriteAccess al rol de ejecución.

X-Ray aplica un algoritmo de muestreo para garantizar que el rastreo sea eficiente, al tiempo que
proporciona una muestra representativa de las solicitudes a las que sirve la aplicación. La regla de
muestreo predeterminada es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales.

Rastreo de aplicaciones basadas en Lambda con

AWS X-Ray
AWS X-Ray es un servicio de AWS que permite detectar, analizar y optimizar problemas de desempeño
en las aplicaciones de AWS Lambda. X-Ray recopila metadatos del servicio de Lambda y de cualquier
servicio anterior o posterior que forme parte de la aplicación. X-Ray utiliza estos metadatos para generar
un gráfico de servicios detallado que ilustra los cuellos de botella de desempeño, picos de latencia y otros
problemas que afectan al desempeño de una aplicación de Lambda.

Después de utilizar el Mapa de servicio de Lambda en AWS X-Ray (p. 405) para identificar un recurso o
componente problemático, puede ampliar el nivel de detalle y ver una representación visual de la solicitud.
Esta representación visual cubre el intervalo de tiempo desde que un origen de eventos activa una función
de Lambda hasta que se completa la ejecución de la función. X-Ray proporciona un desglose de las
operaciones de la función, como, por ejemplo, información sobre las llamadas posteriores que la función
de Lambda ha realizado a otros servicios. Además, la integración de X-Ray con Lambda proporciona
visibilidad de la sobrecarga de servicios de AWS Lambda. Lo hace mostrando detalles como el tiempo de
permanencia de la solicitud y el número de invocaciones.
Note

Los servicios que se integran actualmente con X-Ray son los únicos que se muestran como
rastros independientes, ajenos al rastro de Lambda. Para obtener una lista de los servicios que
admiten X-Ray actualmente, consulte Integración de AWS X-Ray con los servicios de AWS.

Mapa de servicio de Lambda en AWS X-Ray

X-Ray muestra tres tipos de nodos en el mapa de servicio para las solicitudes atendidas por Lambda:

• Servicio de Lambda (AWS::Lambda): este tipo de nodo representa el tiempo que la solicitud ha pasado
en el servicio de Lambda. El tiempo comienza a contar cuando Lambda recibe la solicitud por primera
vez, y finaliza cuando la solicitud sale del servicio de Lambda.
• Función de Lambda (AWS::Lambda::Function): este tipo de nodo representa el tiempo de ejecución de la
función de Lambda.
• Llamadas de servicio posteriores: en este tipo, cada llamada de servicio posterior desde la función de
Lambda se representa mediante su propio nodo.

En el diagrama siguiente, los nodos representan (de izquierda a derecha): el servicio de Lambda, la
función del usuario y una llamada posterior a Amazon S3:

405
 AWS Lambda Guía para desarrolladores
Emisión de segmentos de rastro
desde una función de Lambda

Para obtener más información, consulte Ver el mapa de servicio.

Lambda como rastro de AWS X-Ray

Desde el mapa de servicio, puede ampliar el nivel de detalle para ver una vista de rastros de la función de
Lambda. El rastro mostrará información detallada sobre las invocaciones de la función, representada como
segmentos y subsegmentos:

• Segmento de servicio de Lambda: la información que representa este segmento depende del origen de
eventos utilizado para invocar la función:
• Orígenes de eventos síncronos y de flujo: el segmento de servicio mide el tiempo a partir del momento
en que el servicio de Lambda recibe la solicitud o el evento, y finaliza cuando la solicitud abandona el
servicio de Lambda (después de que se haya completado la invocación final de la solicitud).
• Asíncronos: el segmento de servicio representa el tiempo de respuesta, es decir, el tiempo que tardó
el servicio de Lambda en devolver una respuesta 202 al cliente.

El segmento de servicio de Lambda puede incluir dos tipos de subsegmentos:

• Tiempo de permanencia (solo para las invocaciones asíncronas): representa el tiempo que pasa la
función en el servicio de Lambda antes de su invocación. Este subsegmento comienza cuando el
servicio de Lambda recibe la solicitud o el evento y finaliza cuando se invoca la función de Lambda por
primera vez.
• Intento: representa un solo intento de invocación, incluyendo cualquier sobrecarga introducida por el
servicio de Lambda. Algunos ejemplos de sobrecarga son el tiempo dedicado a inicializar el código de
la función y el tiempo de ejecución de la función.
• Segmento de la función de Lambda: representa el tiempo de ejecución de la función para un intento de
invocación determinado. Se inicia cuando el controlador de la función comienza a ejecutarse y finaliza
cuando la función termina. Este segmento puede incluir tres tipos de subsegmentos:
• Inicialización: el tiempo empleado en ejecutar el código initialization de la función, que es el
código que no pertenece al controlador de la función de Lambda ni a los inicializadores estáticos.
• Llamadas posteriores: llamadas realizadas a otros servicios de AWS desde el código de la función de
Lambda.
• Subsegmentos personalizados: anotaciones del usuario o subsegmentos personalizados que pueden
añadirse al segmento de la función de Lambda utilizando el SDK de X-Ray.

Note

Para cada invocación rastreada, Lambda emite el segmento de servicio de Lambda y todos sus
subsegmentos. Estos segmentos se emiten independientemente del tiempo de ejecución, y tendrá
que utilizar el SDK de X-Ray para las llamadas a la API de AWS.

Emisión de segmentos de rastro desde una función de

Lambda
Para cada invocación rastreada, Lambda emitirá el segmento de servicio de Lambda y todos sus
subsegmentos. Además, Lambda emitirá el segmento de la función de Lambda y el subsegmento de

406
 AWS Lambda Guía para desarrolladores
El demonio de AWS X-Ray en el entorno de Lambda

inicialización. Estos segmentos se emitirán independientemente del tiempo de ejecución de la función y

sin que se necesiten otras bibliotecas ni cambios en el código. Si desea que los rastros de X-Ray de la
función de Lambda incluyan segmentos personalizados, anotaciones o subsegmentos para las llamadas
posteriores, es posible que necesite incluir otras bibliotecas y anotar el código.

Tenga en cuenta que cualquier código de instrumentación debe implementarse dentro del controlador de la
función de Lambda y no como parte del código de inicialización.

En los ejemplos siguientes se explica cómo realizar esta operación en los tiempos de ejecución admitidos:

• Instrumentación del código Python en AWS Lambda (p. 314)

• Instrumentación del código [Link] en AWS Lambda (p. 300)
• Instrumentación del código Java en AWS Lambda (p. 352)
• Instrumentación del código Go en AWS Lambda (p. 369)

El demonio de AWS X-Ray en el entorno de Lambda

El demonio de AWS X-Ray es una aplicación de software que recopila datos de los segmentos sin
procesar y se los transmite al servicio AWS X-Ray. El demonio funciona junto con los SDK de AWS X-Ray
para que los datos que envíen los SDK puedan llegar al servicio de X-Ray.

Cuando se rastrea una función de Lambda, el demonio de X-Ray se ejecuta automáticamente en el

entorno de Lambda para recopilar datos de rastreo y enviarlos a X-Ray. Cuando se realiza el rastreo, el
demonio de X-Ray consume un máximo de 16 MB o el 3 por ciento de la asignación de memoria de la
función. Por ejemplo, si asigna 128 MB de memoria a la función de Lambda, el demonio de X-Ray obtiene
16 MB de la asignación de memoria de la función. Si asigna 1024 MB a la función de Lambda, el demonio
de X-Ray tiene asignados 31 MB (el 3 por ciento). Para obtener más información, consulte El demonio de
AWS X-Ray.
Note

Lambda intentará terminar el demonio de X-Ray para evitar que se supere la cantidad máxima
de memoria de la función. Por ejemplo, supongamos que ha asignado 128 MB a la función de
Lambda, lo que significa que el demonio de X-Ray tendrá asignados 16 MB. Esto deja a la función
de Lambda con una asignación de memoria de 112 MB. Sin embargo, si la función supera los
112 MB, el demonio de X-Ray se terminará para evitar que se produzca un error de memoria.

Uso de variables de entorno para comunicarse con

AWS X-Ray
AWS Lambda utiliza variables de entorno para facilitar la comunicación con el demonio de X-Ray y
configurar el SDK de X-Ray.

• _X_AMZN_TRACE_ID: contiene el encabezado de rastreo, que incluye la decisión de muestreo, el ID

de rastro y el ID del segmento principal. (Para obtener más información acerca de estas propiedades,
consulte Encabezado de rastreo). Si Lambda recibe un encabezado de rastreo cuando se invoca la
función, ese encabezado se utilizará para rellenar la variable de entorno _X_AMZN_TRACE_ID. Si no se
ha recibido un encabezado de rastreo, Lambda generará uno automáticamente.
• AWS_XRAY_CONTEXT_MISSING: el SDK de X-Ray utiliza esta variable para determinar su
comportamiento en caso de que la función intente registrar datos de X-Ray, pero no haya un
encabezado de rastreo de datos disponible. Lambda establece este valor en LOG_ERROR de forma
predeterminada.
• AWS_XRAY_DAEMON_ADDRESS: esta variable de entorno expone la dirección del demonio de X-Ray
con el siguiente formato: DIRECCIÓN_IP:PUERTO. Puede utilizar la dirección del demonio de X-Ray para
enviar datos de rastreo al demonio de X-Ray directamente, sin usar el SDK de X-Ray.

407
 AWS Lambda Guía para desarrolladores
Ejemplos de rastros de Lambda
en la consola de AWS X-Ray

Ejemplos de rastros de Lambda en la consola de AWS

X-Ray
A continuación se muestran rastros de Lambda para dos funciones de Lambda distintas. Cada rastro
muestra una estructura de rastro para un tipo de invocación: asíncrona y síncrona.

• Asíncrona: el siguiente ejemplo muestra una solicitud de Lambda asíncrona con una invocación correcta
y una llamada posterior a DynamoDB.

El segmento de servicio de Lambda encapsula el tiempo de respuesta, que es el tiempo que tarda en
devolver una respuesta (por ejemplo, 202) al cliente. Incluye subsegmentos para el tiempo empleado en
la cola del servicio de Lambda (tiempo de permanencia) y en cada intento de invocación. (En el ejemplo
anterior, solo aparece un intento de invocación). Cada subsegmento de intento del segmento de servicio
tendrá su correspondiente segmento de función del usuario. En este ejemplo, el segmento de función
del usuario contiene dos subsegmentos: el subsegmento de inicialización, que representa el código de
inicialización de la función que se ejecuta antes del controlador, y un subsegmento de llamada posterior
que representa una llamada ListTables a DynamoDB.

Se muestran los códigos de estado y los mensajes de error para cada subsegmento de invocación y
cada llamada posterior.
• Síncrona: el ejemplo siguiente muestra una solicitud síncrona con una llamada posterior a Amazon S3.

408
 AWS Lambda Guía para desarrolladores
CloudTrail

El segmento de servicio de Lambda captura todo el tiempo que la solicitud pasa en el servicio de
Lambda. El segmento de servicio tendrá su correspondiente segmento de función del usuario. En este
ejemplo, el segmento de función del usuario contiene un subsegmento que representa el código de
inicialización de la función (el código que se ejecuta antes del controlador) y un subsegmento que
representa la llamada PutObject a Amazon S3.

Note

Si desea rastrear las llamadas HTTP, debe utilizar un cliente HTTP. Para obtener más
información, consulte Rastreo de llamadas a servicios web HTTP posteriores con X-Ray SDK para
Java o Rastreo de llamadas a servicios web HTTP posteriores utilizando X-Ray SDK para [Link]
.

Registro de llamadas a la API de AWS Lambda con

AWS CloudTrail
AWS Lambda está integrado con AWS CloudTrail, un servicio que proporciona un registro de las acciones
realizadas por un usuario, un rol o un servicio de AWS en AWS Lambda. CloudTrail captura las llamadas
a la API de AWS Lambda como eventos. Las llamadas capturadas incluyen las llamadas desde la consola
de AWS Lambda y las llamadas desde el código a las operaciones de la API de AWS Lambda. Si crea
un registro de seguimiento, puede habilitar la entrega continua de eventos de CloudTrail a un bucket de
Amazon S3, incluidos los eventos de AWS Lambda. Si no configura un registro de seguimiento, puede
ver los eventos más recientes en la consola de CloudTrail en el Event history (Historial de eventos).
Mediante la información que recopila CloudTrail, se puede determinar la solicitud que se envió a AWS
Lambda, la dirección IP desde la que se realizó la solicitud, quién la realizó, cuándo la realizó y los detalles
adicionales.

409
 AWS Lambda Guía para desarrolladores
Información de AWS Lambda en CloudTrail

Para obtener más información sobre CloudTrail, incluido cómo configurarlo y habilitarlo, consulte la AWS
CloudTrail User Guide.

Información de AWS Lambda en CloudTrail

CloudTrail se habilita en una cuenta de AWS al crearla. Cuando se produce una actividad de eventos
compatible en AWS Lambda, dicha actividad se registra en un evento de CloudTrail junto con los eventos
de los demás servicios de AWS en Event history (Historial de eventos). Puede ver, buscar y descargar los
últimos eventos de la cuenta de AWS. Para obtener más información, consulte Visualización de eventos
con el historial de eventos de CloudTrail.

Para mantener un registro continuo de los eventos de la cuenta de AWS, incluidos los eventos de
AWS Lambda, cree un registro de seguimiento. Un registro de seguimiento permite a CloudTrail enviar
archivos de registro a un bucket de Amazon S3. De forma predeterminada, cuando se crea un registro
de seguimiento en la consola, este se aplica a todas las regiones de AWS. El registro de seguimiento
registra los eventos de todas las regiones de la partición de AWS y envía los archivos de registro al bucket
de Amazon S3 especificado. También puede configurar otros servicios de AWS para analizar y actuar en
función de los datos de eventos recopilados en los registros de CloudTrail. Para obtener más información,
consulte los siguientes temas:

• Introducción a la creación de registros de seguimiento

• Servicios e integraciones compatibles con CloudTrail
• Configuración de notificaciones de Amazon SNS para CloudTrail
• Recibir archivos de registro de CloudTrail de varias regiones y Recepción de archivos de registro de
CloudTrail de varias cuentas

AWS Lambda admite el registro de las siguientes acciones como eventos en los archivos de registro de
CloudTrail:

• AddPermission (p. 452)

• CreateEventSourceMapping (p. 460)
• CreateFunction (p. 466)

(Se omite el parámetro ZipFile de los registros de CloudTrail para CreateFunction).

• DeleteEventSourceMapping (p. 477)
• DeleteFunction (p. 481)
• GetEventSourceMapping (p. 496)
• GetFunction (p. 500)
• GetFunctionConfiguration (p. 505)
• GetPolicy (p. 522)
• ListEventSourceMappings (p. 537)
• ListFunctions (p. 543)
• RemovePermission (p. 582)
• UpdateEventSourceMapping (p. 592)
• UpdateFunctionCode (p. 598)

(Se omite el parámetro ZipFile de los registros de CloudTrail para UpdateFunctionCode).

• UpdateFunctionConfiguration (p. 605)

Cada entrada de registro contiene información sobre quién generó la solicitud. La información de identidad
del usuario que figura en el registro le ayudará a determinar si la solicitud se hizo con credenciales de
usuario de IAM o raíz, con credenciales de seguridad temporales para un rol o un usuario federado,

410
 AWS Lambda Guía para desarrolladores
Descripción de las entradas de los
archivos de registro de AWS Lambda

o mediante otro servicio de AWS. Para obtener más información, consulte el campo userIdentity en la
Referencia de eventos de CloudTrail.

Puede guardar los archivos de registro en un bucket durante todo el tiempo que desee, pero también
puede definir reglas de ciclo de vida de Amazon S3 para archivar o eliminar archivos de registro
automáticamente. De forma predeterminada, los archivos de registro se cifran utilizando el cifrado en el
servidor (SSE) de Amazon S3.

Puede hacer que CloudTrail publique notificaciones de Amazon SNS cuando se entreguen nuevos
archivos de registro si desea actuar rápidamente en ese momento. Para obtener más información, consulte
Configuración de notificaciones de Amazon SNS para CloudTrail.

También puede agregar archivos de registro de AWS Lambda de varias regiones de AWS y de varias
cuentas de AWS en un solo bucket de S3. Para obtener más información, consulte Trabajar con archivos
de registro de CloudTrail.

Descripción de las entradas de los archivos de registro

de AWS Lambda
Los archivos de registro de CloudTrail contienen una o varias entradas de registro, cada una de las cuales
se compone de varios eventos en formato JSON. Una entrada de registro representa una única solicitud
de cualquier origen e incluye información sobre la acción solicitada, los parámetros, la fecha y la hora
de la acción, etcétera. Las entradas de registro no se muestran en ningún orden concreto. Es decir, no
representan un rastro de la pila ordenada de las llamadas a API públicas.

En el siguiente ejemplo se muestran entradas de registro de CloudTrail para las acciones GetFunction y
DeleteFunction.

{
"Records": [
{
"eventVersion": "1.03",
"userIdentity": {
"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "myUserName"
},
"eventTime": "2015-03-18T19:03:36Z",
"eventSource": "[Link]",
"eventName": "GetFunction",
"awsRegion": "us-east-1",
"sourceIPAddress": "[Link]",
"userAgent": "Python-httplib2/0.8 (gzip)",
"errorCode": "AccessDenied",
"errorMessage": "User: arn:aws:iam::999999999999:user/myUserName is not
authorized to perform: lambda:GetFunction on resource: arn:aws:lambda:us-
west-2:999999999999:function:other-acct-function",
"requestParameters": null,
"responseElements": null,
"requestID": "7aebcd0f-cda1-11e4-aaa2-e356da31e4ff",
"eventID": "e92a3e85-8ecd-4d23-8074-843aabfe89bf",
"eventType": "AwsApiCall",
"recipientAccountId": "999999999999"
},
{
"eventVersion": "1.03",
"userIdentity": {

411
 AWS Lambda Guía para desarrolladores
Uso de CloudTrail para rastrear invocaciones de funciones

"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "myUserName"
},
"eventTime": "2015-03-18T19:04:42Z",
"eventSource": "[Link]",
"eventName": "DeleteFunction",
"awsRegion": "us-east-1",
"sourceIPAddress": "[Link]",
"userAgent": "Python-httplib2/0.8 (gzip)",
"requestParameters": {
"functionName": "basic-node-task"
},
"responseElements": null,
"requestID": "a2198ecc-cda1-11e4-aaa2-e356da31e4ff",
"eventID": "20b84ce5-730f-482e-b2b2-e8fcc87ceb22",
"eventType": "AwsApiCall",
"recipientAccountId": "999999999999"
}
]
}

Note

eventName puede incluir información de fecha y versión, como "GetFunction20150331",

pero sigue haciendo referencia a la misma API pública. Para obtener más información, consulte
Servicios compatibles con el historial de eventos de CloudTrail en la Guía del usuario de AWS
CloudTrail.

Uso de CloudTrail para rastrear invocaciones de

funciones
CloudTrail registra también los eventos de datos. Puede activar el registro de eventos de datos para
registrar un evento cada vez que se invoquen funciones de Lambda. Esto le ayudará a saber qué
identidades invocan las funciones y la frecuencia de sus invocaciones. Para obtener más información
sobre esta opción, consulte Registro de eventos de datos en los registros de seguimiento.

412
 AWS Lambda Guía para desarrolladores
Protección de los datos

Seguridad en AWS Lambda

La seguridad en la nube de AWS es la mayor prioridad. Como cliente de AWS, se beneficiará de una
arquitectura de red y un centro de datos diseñados para satisfacer los requisitos de seguridad de las
organizaciones más exigentes.

La seguridad es una responsabilidad compartida entre AWS y usted. El modelo de responsabilidad

compartida la describe como seguridad de la nube y seguridad en la nube:

• Seguridad de la nube: AWS es responsable de proteger la infraestructura que ejecuta servicios de

AWS en la nube de AWS. AWS también proporciona servicios que puede utilizar de forma segura.
Auditores externos prueban y verifican periódicamente la eficacia de nuestra seguridad en el marco
de los programas de conformidad de AWS. Para obtener más información acerca de los programas de
conformidad que se aplican a AWS Lambda, consulte Servicios de AWS en el ámbito del programa de
conformidad.
• Seguridad en la nube: su responsabilidad viene determinada por el servicio de AWS que utilice. También
es responsable de otros factores, incluida la confidencialidad de los datos, los requisitos de la empresa y
la legislación y los reglamentos aplicables.

Esta documentación le ayuda a comprender cómo aplicar el modelo de responsabilidad compartida cuando
se utiliza Lambda. En los siguientes temas, se le mostrará cómo configurar Lambda para satisfacer sus
objetivos de seguridad y conformidad. También puede aprender a utilizar otros servicios de AWS que le
ayudan a supervisar y proteger sus recursos de Lambda.

Temas
• Protección de los datos en AWS Lambda (p. 413)
• Administración de identidades y accesos para AWS Lambda (p. 415)
• Validación de la conformidad en AWS Lambda (p. 423)
• Resiliencia de AWS Lambda (p. 423)
• Seguridad de la infraestructura en AWS Lambda (p. 424)
• Configuración y análisis de vulnerabilidades en AWS Lambda (p. 425)

Protección de los datos en AWS Lambda

AWS Lambda cumple los requisitos del modelo de responsabilidad compartida de AWS, que incluye
reglamentos y directrices para la protección de los datos. AWS es responsable de proteger la
infraestructura global que ejecuta todos los servicios de AWS. AWS mantiene el control de los datos
alojados en esta infraestructura, incluidos los controles de configuración de la seguridad para el tratamiento
del contenido y los datos personales de los clientes. Los clientes de AWS y los socios de APN, que actúan
como controladores o procesadores de datos, son responsables de todos los datos personales que
colocan en la nube de AWS.

Para fines de protección de datos, le recomendamos proteger las credenciales de la cuenta de AWS y
configurar cuentas de usuario individuales con AWS Identity and Access Management (IAM), de modo que
a cada usuario se le concedan únicamente los permisos necesarios para llevar a cabo su trabajo. También
le recomendamos proteger sus datos de las siguientes formas:

• Utilice la autenticación multifactor (MFA) con cada cuenta.

413
 AWS Lambda Guía para desarrolladores
Cifrado en tránsito

• Utilice SSL/TLS para comunicarse con los recursos de AWS.

• Configure la API y el registro de actividad del usuario con AWS CloudTrail.
• Utilice las soluciones de cifrado de AWS, junto con todos los controles de seguridad predeterminados
dentro de los servicios de AWS.
• Utilice los servicios de seguridad administrados avanzados como, por ejemplo, Amazon Macie, que
ayudan a detectar y proteger los datos personales almacenados en Amazon S3.

Le recomendamos encarecidamente que nunca introduzca información de identificación confidencial,

como, por ejemplo, números de cuenta de sus clientes, en los campos de formato libre, como los nombres
de función y etiquetas. No debe introducir esta información cuando trabaje con Lambda u otros servicios
de AWS a través de la consola, la API, la AWS CLI o los SDK de AWS. Cualquier dato que escriba en
metadatos se puede incluir en los registros de diagnóstico. Cuando proporcione una URL a un servidor
externo, no incluya información de credenciales en la URL para validar la solicitud para ese servidor.

Para obtener más información sobre la protección de datos, consulte la entrada de blog relativa al modelo
de responsabilidad compartida de AWS y GDPR en el blog de seguridad de AWS.

Secciones
• Cifrado en tránsito (p. 414)
• Cifrado en reposo (p. 414)

Cifrado en tránsito
Los puntos de enlace de API de Lambda solo admiten conexiones seguras a través de HTTPS. Al
administrar recursos de Lambda con el SDK de AWS de Consola de administración de AWS o la API de
Lambda, todas las comunicaciones se cifran con Transport Layer Security (TLS).

Para obtener una lista completa de puntos de enlace de API, consulte Regiones y puntos de enlace de
AWS en la AWS General Reference.

Cifrado en reposo
Puede utilizar las variables de entorno para almacenar claves secretas de forma segura para su uso con
funciones de Lambda. Lambda cifra siempre las variables de entorno en reposo.

Además, puede utilizar las siguientes características para personalizar la forma en que se cifran las
variables de entorno.

• Configuración de clave: en una base por función, puede configurar – Lambda para utilizar una clave de
cifrado que se crea y administra en AWS Key Management Service. Estas operaciones se denominan
claves maestras de cliente administradas por el cliente (CMK) o claves administradas por el cliente. Si
no configura una clave administrada por el cliente, Lambda usa una CMK administrada por AWS llamada
aws/lambda, que Lambda crea en su cuenta.
• Ayudantes de cifrado: la consola de – Lambda le permite cifrar los valores de variables de entorno del
lado del cliente, antes de enviarlos a Lambda. Esto mejora aún más seguridad evitando que los secretos
aparezcan sin cifrar en la consola de Lambda, o en la configuración de la función que devuelve la API
de Lambda. La consola también proporciona el código de muestra que puede adaptar para descifrar los
valores en el controlador de la función.

Para obtener más información, consulte Uso de variables de entorno de AWS Lambda (p. 54).

Lambda siempre cifra los archivos que carga en Lambda, incluidos los paquetes de implementación (p. 21)
y los archivos de capas (p. 74).

414
 AWS Lambda Guía para desarrolladores
Identity and Access Management

Amazon CloudWatch Logs y AWS X-Ray también cifran los datos de manera predeterminada y se pueden
configurar para utilizar una clave administrada por el cliente. Para obtener más información, consulte Cifrar
datos de registro en CloudWatch Logs y Protección de datos en AWS X-Ray.

Administración de identidades y accesos para AWS

Lambda
AWS Identity and Access Management (IAM) es un servicio de AWS que ayuda a un administrador a
controlar de forma segura el acceso a los recursos de AWS. Los administradores de IAM controlan quién
puede ser autenticado (iniciar sesión) y estar autorizado (tener permisos) para utilizar los recursos de
Lambda. IAM es un servicio de AWS que se puede utilizar sin costo adicional.

Temas
• Público (p. 415)
• Autenticación con identidades (p. 415)
• Administración de acceso mediante políticas (p. 417)
• Funcionamiento de AWS Lambda con IAM (p. 419)
• Ejemplos de políticas basadas en identidad (p. 419)
• Solución de problemas de identidad y acceso en AWS Lambda (p. 421)

Público
La forma en que utilice AWS Identity and Access Management (IAM) difiere, en función del trabajo que
realice en Lambda.

Usuario de servicio: si utiliza el servicio Lambda para realizar su trabajo, su administrador le proporciona
las credenciales y los permisos que necesita. A medida que utilice más características de Lambda
para realizar su trabajo, es posible que necesite permisos adicionales. Entender cómo se administra
el acceso puede ayudarle a solicitar los permisos correctos a su administrador. Si no puede acceder
a una característica en Lambda, consulte Solución de problemas de identidad y acceso en AWS
Lambda (p. 421).

Administrador de servicio: si está a cargo de los recursos de Lambda en su empresa, probablemente tenga
acceso completo a Lambda. Su trabajo consiste en determinar qué a características y recursos de Lambda
deben acceder sus empleados. A continuación, debe enviar solicitudes a su administrador de IAM para
cambiar los permisos de los usuarios de su servicio. Revise la información de esta página para conocer los
conceptos básicos de IAM. Para obtener más información sobre cómo su empresa puede utilizar IAM con
Lambda, consulte Funcionamiento de AWS Lambda con IAM (p. 419).

Administrator de IAM: si es un administrador de IAM, es posible que quiera conocer información sobre
cómo escribir políticas para administrar el acceso a Lambda. Para ver ejemplos de políticas basadas
en la identidad de Lambda que puede utilizar en IAM, consulte Ejemplos de políticas basadas en
identidad (p. 419).

Autenticación con identidades

La autenticación es la manera de iniciar sesión en AWS mediante credenciales de identidad. Para obtener
más información acerca del inicio de sesión con la Consola de administración de AWS, consulte La
consola de IAM y la página de inicio de sesión en la Guía del usuario de IAM.

Debe estar autenticado (haber iniciado sesión en AWS) como Usuario de la cuenta raíz de AWS, usuario
de IAM o asumiendo un rol de IAM. También puede utilizar la autenticación de inicio de sesión único de

415
 AWS Lambda Guía para desarrolladores
Autenticación con identidades

su empresa o incluso iniciar sesión con Google o Facebook. En estos casos, su administrador habrá
configurado previamente la federación de identidad mediante roles de IAM. Cuando obtiene acceso a AWS
mediante credenciales de otra empresa, asume un rol indirectamente.

Para iniciar sesión directamente en la Consola de administración de AWS, use su contraseña con su
correo electrónico usuario raíz o su nombre de usuario de IAM. Puede obtener acceso a AWS mediante
programación utilizando sus claves de acceso usuario raíz o de usuario de IAM. AWS proporciona SDK y
herramientas de línea de comandos para firmar criptográficamente su solicitud con sus credenciales. Si no
utiliza las herramientas de AWS, debe firmar usted mismo la solicitud. Para ello, utilice Signature Version
4, un protocolo para autenticar solicitudes de API de entrada. Para obtener más información acerca de la
autenticación de solicitudes, consulte Proceso de firma Signature Version 4 en la AWS General Reference.

Independientemente del método de autenticación que utilice, es posible que también deba proporcionar
información de seguridad adicional. Por ejemplo, AWS le recomienda el uso de la autenticación multifactor
(MFA) para aumentar la seguridad de su cuenta. Para obtener más información, consulte Uso de Multi-
Factor Authentication (MFA) en AWS en la Guía del usuario de IAM.

Usuario raíz de la cuenta de AWS

Cuando se crea por primera vez una cuenta de AWS, se comienza con una única identidad de inicio de
sesión que tiene acceso completo a todos los servicios y recursos de AWS de la cuenta. Esta identidad
recibe el nombre de AWS de la cuenta de usuario raíz y se obtiene acceso a ella iniciando sesión con la
dirección de correo electrónico y la contraseña que utilizó para crear la cuenta. Le recomendamos que
no utilice usuario raíz en sus tareas cotidianas, ni siquiera en las tareas administrativas. En lugar de ello,
es mejor ceñirse a la práctica recomendada de utilizar exclusivamente usuario raíz para crear el primer
usuario de IAM. A continuación, guarde las credenciales de usuario raíz en un lugar seguro y utilícelas
únicamente para algunas tareas de administración de cuentas y servicios.

Usuarios y grupos de IAM

Un usuario de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos para una
sola persona o aplicación. Un usuario de IAM puede tener credenciales a largo plazo, como un nombre
de usuario y una contraseña o un conjunto de claves de acceso. Para obtener más información acerca de
cómo generar claves de acceso, consulte Administración de las claves de acceso de los usuarios de IAM
en la Guía del usuario de IAM. Al generar claves de acceso para un usuario de IAM, asegúrese de ver y
guardar de forma segura el par de claves. No puede recuperar la clave de acceso secreta en el futuro. En
su lugar, debe generar un nuevo par de claves de acceso.

Un grupo de IAM es una identidad que especifica un conjunto de usuarios de IAM. No puede iniciar sesión
como grupo. Puede usar los grupos para especificar permisos para varios usuarios a la vez. Los grupos
facilitan la administración de los permisos de grandes conjuntos de usuarios. Por ejemplo, podría tener un
grupo cuyo nombre fuese Administradores de IAM y conceder permisos a dicho grupo para administrar los
recursos de IAM.

Los usuarios son diferentes de los roles. Un usuario se asocia exclusivamente a una persona o aplicación,
pero la intención es que cualquier usuario pueda asumir un rol que necesite. Los usuarios tienen
credenciales permanentes a largo plazo y los roles proporcionan credenciales temporales. Para obtener
más información, consulte Cuándo crear un usuario de IAM (en lugar de un rol) en la Guía del usuario de
IAM.

Roles de IAM
Un rol de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos. Es similar a
un usuario de IAM, pero no está asociado a una determinada persona. Puede asumir temporalmente un
rol de IAM en la Consola de administración de AWS cambiando de roles. Puede asumir un rol llamando
a una operación de la AWS CLI o de la API de AWS, o utilizando una URL personalizada. Para obtener
más información acerca de los métodos para el uso de roles, consulte Uso de roles de IAM en la Guía del
usuario de IAM.

416
 AWS Lambda Guía para desarrolladores
Administración de acceso mediante políticas

Los roles de IAM con credenciales temporales son útiles en las siguientes situaciones:

• Permisos de usuario temporales de IAM: un usuario de IAM puede asumir un rol de IAM para recibir
temporalmente permisos distintos que le permitan realizar una tarea concreta.
• Acceso de usuario federado: En lugar de crear un usuario de IAM, puede utilizar identidades existentes
de AWS Directory Service, del directorio de usuarios de la empresa o de un proveedor de identidades
web. A estas identidades se les llama usuarios federados. AWS asigna una función a un usuario
federado cuando se solicita acceso a través de un proveedor de identidad. Para obtener más
información acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía del
usuario de IAM.
• Acceso entre cuentas: puede utilizar un rol de IAM para permitir que alguien (una entidad principal de
confianza) de otra cuenta obtenga acceso a los recursos de su cuenta. Los roles son la forma principal
de conceder acceso entre cuentas. Sin embargo, con algunos servicios de AWS, puede asociar una
política directamente a un recurso (en lugar de utilizar un rol como proxy). Para obtener información
acerca de la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas,
consulte Cómo los roles de IAM difieren de las políticas basadas en recursos en la Guía del usuario de
IAM.
• Acceso a servicios de AWS: Un rol de servicio es un rol de IAM que un servicio asume para realizar
acciones en su cuenta en su nombre. Al configurar algunos de los entornos de los servicios de AWS,
debe definir un rol que el servicio asumirá. Este rol de servicio debe incluir todos los permisos que
son necesarios para que el servicio pueda acceder a los recursos de AWS que necesita. Los roles de
servicio varían de servicio a servicio, pero muchos le permiten elegir sus permisos, siempre y cuando
se cumplan los requisitos documentados para dicho servicio. Los roles de servicio ofrecen acceso solo
dentro de su cuenta y no se pueden utilizar para otorgar acceso a servicios en otras cuentas. Puede
crear, modificar y eliminar un rol de servicio desde IAM. Por ejemplo, puede crear un rol que permita
a Amazon Redshift tener acceso a un bucket de Amazon S3 en su nombre y, a continuación, cargar
los datos de ese bucket en un clúster de Amazon Redshift. Para obtener más información, consulte
Creación de un rol para delegar permisos a un servicio de AWS en la Guía del usuario de IAM.
• Aplicaciones que se ejecutan en Amazon EC2: Puede utilizar un rol de IAM para administrar
credenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizan
solicitudes de la AWS CLI o la API de AWS. Es preferible hacerlo de este modo a almacenar claves de
acceso en la instancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición de
todas las aplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene el
rol y permite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Para
obtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones que se
ejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.

Para obtener información acerca del uso de los roles de IAM, consulte Cuándo crear un rol de IAM (en vez
de un usuario) en la Guía del usuario de IAM.

Administración de acceso mediante políticas

Para controlar el acceso en AWS, se crean políticas y se asocian a identidades de IAM o recursos de
AWS. Una política es un objeto de AWS que, cuando se asocia a una identidad o un recurso, define
sus permisos. AWS evalúa estas políticas cuando una entidad principal (usuario raíz, usuario de IAM o
rol de IAM) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o se
deniega. Las mayoría de las políticas se almacenan en AWS como documentos JSON. Para obtener
más información acerca de la estructura y el contenido de los documentos de política JSON, consulte
Información general de las políticas de JSON en la Guía del usuario de IAM.

Un administrador de IAM puede utilizar las políticas para especificar quién tiene acceso a los recursos de
AWS y qué acciones se pueden realizar en dichos recursos. Cada entidad de IAM (usuario o rol) comienza
sin permisos. En otras palabras, de forma predeterminada, los usuarios no pueden hacer nada, ni siquiera
cambiar sus propias contraseñas. Para conceder permiso a un usuario para hacer algo, el administrador
debe asociarle una política de permisos. O bien el administrador puede añadir al usuario a un grupo que

417
 AWS Lambda Guía para desarrolladores
Administración de acceso mediante políticas

tenga los permisos necesarios. Cuando el administrador concede permisos a un grupo, todos los usuarios
de ese grupo obtienen los permisos.

Las políticas de IAM definen permisos para una acción independientemente del método que se utilice
para realizar la operación. Por ejemplo, suponga que dispone de una política que permite la acción
iam:GetRole. Un usuario con dicha política puede obtener información del usuario de la Consola de
administración de AWS, la AWS CLI o la API de AWS.

Políticas basadas en la identidad

Las políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociar
a una identidad, como por ejemplo un usuario, un rol o un grupo de IAM. Estas políticas controlan qué
acciones puede realizar dicha identidad, en qué recursos y en qué condiciones. Para obtener más
información acerca de cómo crear una política basada en identidad, consulte Creación de políticas de IAM
en la Guía del usuario de IAM.

Las políticas basadas en identidad pueden clasificarse además como políticas insertadas o políticas
administradas. Las políticas insertadas se integran directamente en un único usuario, grupo o rol. Las
políticas administradas son políticas independientes que puede asociar a varios usuarios, grupos y roles
de su cuenta de AWS. Las políticas administradas incluyen las políticas administradas por AWS y las
políticas administradas por el cliente. Para obtener más información acerca de cómo elegir una política
administrada o una política insertada, consulte Elegir entre políticas administradas y políticas insertadas en
la Guía del usuario de IAM.

Políticas basadas en recursos

Las políticas basadas en recursos son documentos de política JSON que puede asociar a un recurso
como, por ejemplo, un bucket de Amazon S3. Los administradores de servicios pueden utilizar estas
políticas para definir qué acciones puede realizar un principal especificado (miembro de cuenta, usuario o
rol) en dicho recurso y bajo qué condiciones. Las políticas basadas en recursos son políticas insertadas.
No existen políticas basadas en recursos que sean administradas.

Listas de control de acceso (ACL)

Las listas de control de acceso (ACL) son un tipo de política que controlan qué entidades principales
(cuentas, miembros, usuarios o roles) tienen permisos para obtener acceso a un recurso. Las ACL son
similares a las políticas basadas en recursos, aunque no utilizan el formato de documento de política
JSON. Amazon S3, AWS WAF y Amazon VPC son ejemplos de servicios que admiten ACL. Para obtener
más información sobre las ACL, consulte Información general de las Access Control Lists (ACL, Listas de
control de acceso) en la Guía para desarrolladores de Amazon Simple Storage Service.

Otros tipos de políticas

AWS admite otros tipos de políticas menos frecuentes. Estos tipos de políticas pueden establecer el
máximo de permisos que los tipos de políticas más frecuentes le otorgan.

• Límites de permisos: un límite de permisos es una característica avanzada que le permite definir los
permisos máximos que una política basada en identidad puede conceder a una entidad de IAM (usuario
o rol de IAM). Puede establecer un límite de permisos para una identidad. Los permisos resultantes son
la intersección de las políticas basadas en identidades de la entidad y los límites de sus permisos. Las
políticas basadas en recursos que especifiquen el usuario o rol en el campo Principal no estarán
restringidas por el límite de permisos. Una denegación explícita en cualquiera de estas políticas anulará
el permiso. Para obtener más información acerca de los límites de permisos, consulte see Límites de
permisos para las entidades de IAM en la Guía del usuario de IAM.
• Políticas de control de servicios (SCP): las SCP son políticas de JSON que especifican los permisos
máximos para una organización o unidad organizativa (OU) en AWS Organizations. AWS Organizations

418
 AWS Lambda Guía para desarrolladores
Funcionamiento de AWS Lambda con IAM

es un servicio que le permite agrupar y administrar de forma centralizada varias cuentas de AWS
que posee su negocio. Si habilita todas las funciones en una organización, entonces podrá aplicar
políticas de control de servicio (SCP) a una o todas sus cuentas. Una SCP limita los permisos para las
entidades de las cuentas de miembros, incluido cada Usuario de la cuenta raíz de AWS. Para obtener
más información acerca de Organizaciones y las SCP, consulte Funcionamiento de las SCP en la Guía
del usuario de AWS Organizations.
• Políticas de sesión: las políticas de sesión son políticas avanzadas que se pasan como parámetro
cuando se crea una sesión temporal mediante programación para un rol o un usuario federado. Los
permisos de la sesión resultantes son la intersección de las políticas basadas en identidades del rol y las
políticas de la sesión. Los permisos también pueden proceder de una política basada en recursos. Una
denegación explícita en cualquiera de estas políticas anulará el permiso. Para obtener más información,
consulte Políticas de sesión en la Guía del usuario de IAM.

Varios tipos de políticas

Cuando se aplican varios tipos de políticas a una solicitud, los permisos resultantes son más complicados
de entender. Para obtener información acerca de cómo AWS determina si permitir una solicitud cuando
hay varios tipos de políticas implicados, consulte Lógica de evaluación de políticas en la Guía del usuario
de IAM.

Funcionamiento de AWS Lambda con IAM

Antes de utilizar IAM para administrar el acceso a Lambda, debe saber qué características de IAM están
disponibles para su uso con Lambda. Para obtener una perspectiva general de cómo Lambda y otros
servicios de AWS funcionan con IAM, consulte Servicios de AWS que funcionan con IAM en la Guía del
usuario de IAM.

Para obtener información general acerca de los permisos, las políticas y funciones a medida que Lambda
utiliza, consulte Permisos de AWS Lambda (p. 32).

Ejemplos de políticas basadas en identidad

De forma predeterminada, los usuarios y roles de IAM no tienen permiso para crear, ver ni modificar
recursos de Lambda. Tampoco pueden realizar tareas mediante la Consola de administración de AWS, la
AWS CLI, o la API de AWS. Un administrador de IAM debe crear políticas de IAM que concedan permisos
a los usuarios y a los roles para realizar operaciones de la API concretas en los recursos especificados
que necesiten. El administrador debe adjuntar esas políticas a los usuarios o grupos de IAM que necesiten
esos permisos.

Para obtener más información acerca de cómo crear una política basada en identidad de IAM con estos
documentos de políticas de JSON de ejemplo, consulte Creación de políticas en la pestaña JSON en la
Guía del usuario de IAM.

Temas
• Prácticas recomendadas relativas a políticas (p. 419)
• Mediante la consola de Lambda (p. 420)
• Permitir a los usuarios ver sus propios permisos (p. 420)

Prácticas recomendadas relativas a políticas

Las políticas basadas en identidad son muy eficaces. Determinan si alguien puede crear, acceder o
eliminar los recursos de Lambda de su cuenta. Estas acciones pueden generar costes adicionales para su
cuenta de AWS. Siga estas directrices y recomendaciones al crear o editar políticas basadas en identidad:

419
 AWS Lambda Guía para desarrolladores
Ejemplos de políticas basadas en identidad

• Introducción sobre el uso de políticas administradas de AWS: para comenzar a utilizar Lambda
rápidamente, utilice las políticas administradas de AWS para proporcionar a los empleados los permisos
necesarios. Estas políticas ya están disponibles en su cuenta y las mantiene y actualiza AWS. Para
obtener más información, consulte Introducción sobre el uso de permisos con políticas administradas de
AWS en la Guía del usuario de IAM.
• Conceder privilegios mínimos: al crear políticas personalizadas, conceda solo los permisos necesarios
para llevar a cabo una tarea. Comience con un conjunto mínimo de permisos y conceda permisos
adicionales según sea necesario. Por lo general, es más seguro que comenzar con permisos que son
demasiado tolerantes e intentar hacerlos más severos más adelante. Para obtener más información,
consulte Conceder privilegios mínimos en la Guía del usuario de IAM.
• Habilitar MFA para operaciones confidenciales: para mayor seguridad, obligue a los usuarios de
IAM a que utilicen la autenticación multifactor (MFA) para acceder a recursos u operaciones de API
confidenciales. Para obtener más información, consulte Uso de Multi-Factor Authentication (MFA) en
AWS en la Guía del usuario de IAM.
• Utilizar condiciones de política para mayor seguridad: en la medida en que sea práctico, defina las
condiciones en las que sus políticas basadas en identidad permitan el acceso a un recurso. Por ejemplo,
puede escribir condiciones para especificar un rango de direcciones IP permitidas desde el que debe
proceder una solicitud. También puede escribir condiciones para permitir solicitudes solo en un intervalo
de hora o fecha especificado o para solicitar el uso de SSL o MFA. Para obtener más información,
consulte Elementos de la política de JSON de IAM: condición en la Guía del usuario de IAM.

Mediante la consola de Lambda

Para acceder a la consola de AWS Lambda, debe tener un conjunto mínimo de permisos. Estos permisos
deben permitirle registrar y consultar los detalles sobre los recursos de Lambda en su cuenta de AWS. Si
crea una política basada en identidad que sea más restrictiva que el mínimo de permisos necesarios, la
consola no funcionará del modo esperado para las entidades (usuarios o roles de IAM) que tengan esa
política.

Para obtener un ejemplo de política que concede un acceso mínimo para el desarrollo de funciones,
consulte Desarrollo de funciones (p. 41). Además de las API de Lambda, la consola de Lambda utiliza
otros servicios para mostrar la configuración de activación y permitir agregar nuevos desencadenadores.
Si sus usuarios usan Lambda con otros servicios, también necesitan acceso a esos servicios. Para obtener
más información sobre cómo configurar otros servicios con Lambda, consulte Uso de AWS Lambda con
otros servicios (p. 153).

Permitir a los usuarios ver sus propios permisos

En este ejemplo, se muestra cómo podría crear una política que permita a los usuarios de IAM ver las
políticas administradas e insertadas que se asocian a la identidad de sus usuarios. Esta política incluye
permisos para llevar a cabo esta acción en la consola o mediante programación con la AWS CLI o la API
de AWS.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]

420
 AWS Lambda Guía para desarrolladores
Solución de problemas

},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}

Solución de problemas de identidad y acceso en AWS

Lambda
Utilice la información siguiente para diagnosticar y solucionar los problemas comunes que puedan surgir
cuando trabaje con Lambda e IAM.

Temas
• No tengo autorización para realizar una acción en Lambda (p. 421)
• No tengo autorización para realizar la operación iam:PassRole (p. 421)
• Quiero ver mis claves de acceso (p. 422)
• Soy administrador y deseo permitir que otros obtengan acceso a Lambda (p. 422)
• Quiero permitir a personas externas a mi cuenta de AWS el acceso a mis recursos de
Lambda (p. 422)

No tengo autorización para realizar una acción en Lambda

Si la Consola de administración de AWS le indica que no está autorizado para llevar a cabo una acción,
debe ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le
facilitó su nombre de usuario y contraseña.

En el siguiente ejemplo, el error se produce cuando el usuario de IAM, mateojackson intenta utilizar la
consola para ver detalles sobre una función, pero no tiene permisos lambda:GetFunction.

User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform:

lambda:GetFunction on resource: my-function

En este caso, Mateo pide a su administrador que actualice sus políticas de forma que pueda obtener
acceso al recurso my-function mediante la acción lambda:GetFunction.

No tengo autorización para realizar la operación iam:PassRole

Si recibe un error que indica que no está autorizado para llevar a cabo la acción iam:PassRole, debe
ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le facilitó
su nombre de usuario y contraseña. Pida a la persona que actualice sus políticas de forma que pueda
transferir un rol a Lambda.

421
 AWS Lambda Guía para desarrolladores
Solución de problemas

Algunos servicios de AWS le permiten transferir un rol existente a dicho servicio en lugar de crear un nuevo
rol de servicio o uno vinculado al servicio. Para ello, debe tener permisos para transferir el rol al servicio.

En el siguiente ejemplo, el error se produce cuando un usuario de IAM denominado marymajor intenta
utilizar la consola para realizar una acción en Lambda. Sin embargo, la acción requiere que el servicio
cuente con permisos otorgados por un rol de servicio. Mary no tiene permisos para transferir el rol al
servicio.

User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole

En este caso, Mary pide a su administrador que actualice sus políticas para que pueda realizar la acción
iam:PassRole.

Quiero ver mis claves de acceso

Después de crear sus claves de acceso de usuario de IAM, puede ver su ID de clave de acceso en
cualquier momento. Sin embargo, no puede volver a ver su clave de acceso secreta. Si pierde la clave de
acceso secreta, debe crear un nuevo par de claves de acceso.

Las claves de acceso se componen de dos partes: un ID de clave de acceso (por ejemplo,
AKIAIOSFODNN7EXAMPLE) y una clave de acceso secreta (por ejemplo, wJalrXUtnFEMI/K7MDENG/
bPxRfiCYEXAMPLEKEY). El ID de clave de acceso y la clave de acceso secreta se utilizan juntos, como un
nombre de usuario y contraseña, para autenticar sus solicitudes. Administre sus claves de acceso con el
mismo nivel de seguridad que para el nombre de usuario y la contraseña.
Important

No proporcione las claves de acceso a terceras personas, ni siquiera para que le ayuden a buscar
el ID de usuario canónico. Si lo hace, podría conceder a otra persona acceso permanente a su
cuenta.

Cuando cree un par de claves de acceso, se le pide que guarde el ID de clave de acceso y la clave de
acceso secreta en un lugar seguro. La clave de acceso secreta solo está disponible en el momento de su
creación. Si pierde la clave de acceso secreta, debe añadir nuevas claves de acceso a su usuario de IAM.
Puede tener un máximo de dos claves de acceso. Si ya cuenta con dos, debe eliminar un par de claves
antes de crear uno nuevo. Para ver las instrucciones, consulte Administración de las claves de acceso en
la Guía del usuario de IAM.

Soy administrador y deseo permitir que otros obtengan acceso a

Lambda
Para permitir que otros obtengan acceso a Lambda, debe crear una entidad de IAM (usuario o rol) para
la persona o aplicación que necesita acceso. Esta persona utilizará las credenciales de la entidad para
obtener acceso a AWS. A continuación, debe asociar una política a la entidad que le conceda los permisos
correctos en Lambda.

Para comenzar de inmediato, consulte Creación del primer grupo y usuario delegado de IAM en la Guía del
usuario de IAM.

Quiero permitir a personas externas a mi cuenta de AWS el

acceso a mis recursos de Lambda
Puede crear un rol que los usuarios de otras cuentas o las personas externas a la organización puedan
utilizar para acceder a sus recursos. Puede especificar una persona de confianza para que asuma el rol.

422
 AWS Lambda Guía para desarrolladores
Validación de la conformidad

En el caso de los servicios que admitan las políticas basadas en recursos o las listas de control de acceso
(ACL), puede utilizar dichas políticas para conceder a las personas acceso a sus recursos.

Para obtener más información, consulte lo siguiente:

• Para obtener información acerca de si Lambda admite estas características, consulte Funcionamiento de
AWS Lambda con IAM (p. 419).
• Para aprender cómo proporcionar acceso a sus recursos en cuentas de AWS de su propiedad, consulte
Proporcionar acceso a un usuario de IAM a otra cuenta de AWS de la que es propietario en la Guía del
usuario de IAM.
• Para obtener información acerca de cómo ofrecer acceso a sus recursos a cuentas de AWS de terceros,
consulte Proporcionar acceso a las cuentas de AWS propiedad de terceros en la Guía del usuario de
IAM.
• Para obtener información acerca de cómo ofrecer acceso a la identidad federada, consulte Proporcionar
acceso a usuarios autenticados externamente (identidad federada) en la Guía del usuario de IAM.
• Para obtener información acerca de la diferencia entre utilizar los roles y las políticas basadas en
recursos para el acceso entre cuentas, consulte Cómo los roles de IAM difieren de las políticas basadas
en recursos en la Guía del usuario de IAM.

Validación de la conformidad en AWS Lambda

Auditores externos evalúan la seguridad y la conformidad de AWS Lambda como parte de varios
programas de conformidad de AWS. Estos incluye SOC, PCI, FedRAMP, HIPAA y otros.

Para obtener una lista de los servicios de AWS en el ámbito de programas de conformidad específicos,
consulte Servicios de AWS en el ámbito del programa de conformidad. Para obtener información general,
consulte Programas de conformidad de AWS.

Puede descargar los informes de auditoría de terceros utilizando AWS Artifact. Para obtener más
información, consulte la sección Descarga de informes en AWS Artifact.

Su responsabilidad de conformidad al utilizar Lambda se determina en función de la sensibilidad de los

datos, los objetivos de cumplimiento de su empresa y la legislación y los reglamentos correspondientes.
AWS proporciona los siguientes recursos para ayudar con la conformidad:

• Guías de inicio rápido de seguridad y conformidad: estas guías de implementación tratan

consideraciones sobre arquitectura y ofrecen pasos para implementar los entornos de referencia
centrados en la seguridad y la conformidad en AWS.
• Documento técnico sobre arquitectura para seguridad y conformidad de HIPAA: este documento técnico
describe cómo las empresas pueden utilizar AWS para crear aplicaciones conformes con HIPAA.
• Recursos de conformidad de AWS: este conjunto de manuales y guías podría aplicarse a su sector y
ubicación.
• AWS Config: este servicio de AWS evalúa en qué medida las configuraciones de los recursos cumplen
las prácticas internas, las directrices del sector y las normativas.
• AWS Security Hub: este servicio de AWS ofrece una vista integral de su estado de seguridad en AWS
que le ayuda a comprobar la conformidad con las normas del sector de seguridad y las prácticas
recomendadas.

Resiliencia de AWS Lambda

La infraestructura global de AWS está conformada por regiones y zonas de disponibilidad de AWS. Las
regiones de AWS proporcionan varias zonas de disponibilidad físicamente independientes y aisladas

423
 AWS Lambda Guía para desarrolladores
Seguridad de la infraestructura

que se encuentran conectadas mediante redes con un alto nivel de rendimiento y redundancia, además
de baja latencia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datos
que realizan una conmutación por error automática entre zonas de disponibilidad sin interrupciones. Las
zonas de disponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las
infraestructuras tradicionales de centros de datos únicos o múltiples.

Para obtener más información sobre zonas de disponibilidad y las regiones de AWS, consulte
Infraestructura global de AWS.

Además de la infraestructura global de AWS, Lambda ofrece varias características que le ayudan con sus
necesidades de resiliencia y copia de seguridad de los datos.

• Control de versiones: Puede utilizar el control de versiones en – Lambda para guardar el código de la
función y la configuración a medida que realice el desarrollo. Junto con los alias, puede utilizar el control
de versiones para realizar implementaciones continuas y blue/green. Para obtener más información,
consulte Versiones de funciones de AWS Lambda (p. 68).
• Escalado:: cuando la función recibe una solicitud mientras procesa una solicitud anterior, Lambda
lanza otra instancia de su función para administrar el aumento de la carga. Lambda automáticamente
se escala para gestionar 1,000 ejecuciones simultáneas por región, un límite (p. 30) que puede
aumentarse si es necesario. Para obtener más información, consulte Escalado de funciones de AWS
Lambda (p. 102).
• Alta disponibilidad: – Lambda ejecuta la función en varias zonas de disponibilidad para asegurarse de
que está disponible para procesar eventos en caso de una interrupción del servicio en una sola zona.
Si configura la función para conectarse a una nube privada virtual (VPC) en su cuenta, especifique
subredes en varias zonas de disponibilidad para garantizar una alta disponibilidad. Para obtener más
información, consulte Configuración de una función Lambda para obtener acceso a los recursos en una
VPC (p. 78).
• Simultaneidad reservada: – para asegurarse de que la función siempre puede escalarse para gestionar
solicitudes adicionales, puede reservar la simultaneidad para ella. Configurar la simultaneidad reservada
para una función garantiza que se puede escalar, pero no superar, un determinado número de
invocaciones simultáneas. De este modo, se asegura de que no pierde las solicitudes debido a otras
funciones que consumen toda la simultaneidad disponible. Para obtener más información, consulte
Administración de la simultaneidad para una función Lambda (p. 59).
• Reintentos: en invocaciones asíncronas y un subconjunto de invocaciones activadas por otros servicios,
Lambda reintenta automáticamente en error con retrasos entre los reintentos. Otros clientes y servicios
de AWS que invocan de forma sincrónica son responsables de realizar los reintentos. Para obtener más
información, consulte Control de errores y reintentos automáticos en AWS Lambda (p. 107).
• Cola de mensajes fallidos: – en invocaciones asíncronas, puede configurar Lambda para enviar
solicitudes a una cola de mensajes fallidos si fallan todos los reintentos. Una cola de mensajes fallidos
es un tema de Amazon SNS o una cola de Amazon SQS que recibe eventos para la resolución de
problemas o para reprocesamiento. Para obtener más información, consulte Colas de mensajes fallidos
de funciones de AWS Lambda (p. 95).

Seguridad de la infraestructura en AWS Lambda

Al tratarse de un servicio administrado, AWS Lambda está protegido por los procedimientos de seguridad
de red globales de AWS que se describen en el documento técnico Amazon Web Services: Información
general sobre procesos de seguridad.

Puede utilizar llamadas a la API publicadas en AWS para obtener acceso a Lambda a través de la red.
Los clientes deben ser compatibles con Transport Layer Security (TLS) 1.0 o una versión posterior.
Le recomendamos TLS 1.2 o una versión posterior. Los clientes también deben ser compatibles con
conjuntos de cifrado con confidencialidad directa total (PFS) tales como Ephemeral Diffie-Hellman (DHE)
o Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). La mayoría de los sistemas modernos como Java 7 y
posteriores son compatibles con estos modos.

424
 AWS Lambda Guía para desarrolladores
Configuración y análisis de vulnerabilidades

Además, las solicitudes deben estar firmadas mediante un ID de clave de acceso y una clave de acceso
secreta que esté asociada a una entidad principal de IAM. También puede utilizar AWS Security Token
Service (AWS STS) para generar credenciales de seguridad temporales para firmar solicitudes.

Configuración y análisis de vulnerabilidades en

AWS Lambda
AWS Lambda proporciona tiempos de ejecución (p. 118) que ejecutan su código de función en un entorno
de ejecución basado en Linux de Amazon.– Lambda es responsable de mantener el software en tiempo
de ejecución y el entorno de ejecución actualizado, publicando nuevos tiempos de ejecución para nuevos
lenguajes y marcos y dejará de proporcionar tiempos de ejecución cuando el software subyacente deje de
admitirse.

Si utiliza bibliotecas adicionales con su función, será responsable de actualizar las bibliotecas. Puede
incluir bibliotecas adicionales en el paquete de implementación (p. 21) o en capas (p. 74) que asocie
a su función. También puede crear tiempos de ejecución personalizados (p. 121) y utilizar capas para
compartirlas con otras cuentas.

Lambda descarta tiempos de ejecución cuando el software en el tiempo de ejecución o su entorno

de ejecución alcanza el final de su vida útil. Cuando Lambda descarta un tiempo de ejecución, será
responsable de migrar sus funciones a un tiempo de ejecución compatible para el mismo lenguaje o marco.
Para obtener más información, consulte Política de soporte del tiempo de ejecución (p. 120).

425
 AWS Lambda Guía para desarrolladores
Implementación

Solución de problemas de AWS

Lambda
Los temas siguientes proporcionan consejos para solucionar problemas de errores y problemas que
puedan surgir al utilizar la API de Lambda, la consola o las herramientas. Si se encuentra con un problema
que no aparezca en esta lista, puede utilizar el botón Feedback (Comentarios) de esta página para
notificarlo.

Para obtener más consejos para la resolución de problemas y respuestas a preguntas comunes de
soporte, visite el Centro de conocimientos de AWS.

Temas
• Solución de problemas en las implementaciones de AWS Lambda (p. 426)
• Solucionar problemas de invocación en AWS Lambda (p. 428)
• Solucionar problemas de ejecución en AWS Lambda (p. 430)
• Solucionar problemas de redes en AWS Lambda (p. 431)

Solución de problemas en las implementaciones de

AWS Lambda
Al actualizar su función, Lambda implementa el cambio iniciando nuevas instancias de la función con el
código o la configuración actualizados. Los errores de implementación impiden que se utilice la nueva
versión y pueden deberse a problemas con el paquete de implementación, el código, los permisos o las
herramientas.

Cuando implementa actualizaciones en su función directamente con la API de Lambda o con un cliente
como la AWS CLI, puede ver errores de Lambda directamente en la salida. Si utiliza servicios como AWS
CloudFormation, AWS CodeDeploy o AWS CodePipeline, busque la respuesta de Lambda en los registros
o en la secuencia de eventos del servicio.

Error: EACCES: permission denied, open '/var/task/[Link]'

Error: cannot load such file -- function

Error: [Errno 13] Permission denied: '/var/task/[Link]'

El runtime de Lambda necesita permiso para leer los archivos del paquete de implementación. Puede
utilizar el comando chmod para cambiar el modo de archivo. Los siguientes comandos de ejemplo permiten
que cualquier usuario pueda leer todos los archivos y carpetas del directorio actual.

my-function$ chmod 644 $(find . -type f)

my-function$ chmod 755 $(find . -type d)

Error: An error occurred (RequestEntityTooLargeException) when calling the UpdateFunctionCode

operation

426
 AWS Lambda Guía para desarrolladores
Implementación

Cuando carga un paquete de implementación o un archivo de capa directamente en Lambda, el tamaño

del archivo ZIP está limitado a 50 MB. Para cargar un archivo más grande, almacénelo en Amazon S3 y
utilice los parámetros S3Bucket y S3Key (p. 599) .
Note

Cuando carga un archivo directamente con la AWS CLI, el SDK de AWS o de otro modo, el
archivo ZIP binario se convierte a base64, que aumenta su tamaño en aproximadamente un 30 %.
Para permitir esto y el tamaño de otros parámetros de la solicitud, el límite de tamaño de solicitud
real que aplica Lambda es mayor. Por este motivo, el límite de 50 MB es aproximado.

Error: se produjo un error mientras GetObject. Código de error S3: PermanentRedirect. Mensaje de error
S3: el bucket está en esta región: us-east-2. Utilice esta región para volver a intentar la solicitud

Cuando carga el paquete de implementación de una función desde un bucket Amazon S3, el bucket
debe estar en la misma Región que la función. Este problema puede producirse cuando especifica un
Amazon S3 objeto en una llamada a UpdateFunctionCode (p. 598), o utiliza el paquete y los comandos
de implementación en la CLI de AWS o en la CLI de AWS SAM. Cree un depósito de artefactos de
implementación para cada Región donde desarrolle aplicaciones.

Error: Cannot find module 'function'

Error: cannot load such file -- function

Error: Unable to import module 'function'

Error: Class not found: [Link]

Error: fork/exec /var/task/function: no such file or directory

Error: Unable to load type '[Link]' from assembly 'Function'.

El nombre del archivo o clase en la configuración del controlador de su función no coincide con su código.
Consulte la siguiente entrada para obtener más información.

Error: [Link] is undefined or not exported

Error: Handler 'handler' missing on module 'function'

Error: undefined method `handler' for #<LambdaHandler:0x000055b76ccebf98>

Error: No public method named handleRequest with appropriate method signature found on class class
[Link]

Error: Unable to find method 'handleRequest' in type '[Link]' from assembly 'Function'

El nombre del método de controlador en la configuración del controlador de su función no coincide con su
código. Cada motor de ejecución define una convención de nomenclatura para los controladores, como
[Link]étodo. El controlador es el método en el código de su función ejecutado
por el tiempo de ejecución cuando se invoca la función.

En algunos idiomas, Lambda proporciona una biblioteca con una interfaz que espera que un método de
controlador tenga un nombre específico. Para obtener información detallada sobre la nomenclatura de
controladores para cada idioma, consulte los temas siguientes.

• Creación de funciones de Lambda con [Link] (p. 289)

• Creación de funciones de Lambda con Python (p. 302)
• Creación de funciones Lambda con Ruby (p. 317)
• Creación de funciones de Lambda con Java (p. 328)

427
 AWS Lambda Guía para desarrolladores
Invocación

• Creación de funciones de Lambda con Go (p. 359)

• Creación de funciones de Lambda con C# (p. 372)
• Creación de funciones de Lambda con PowerShell (p. 390)

Error: InvalidParameterValueException: Lambda no pudo configurar las variables de entorno porque

las variables de entorno que ha proporcionado han excedido el límite de 4 KB. Cadena medida:
{"A1":"uSFeY5cyPiPn7AtnX5BsM...

Error: RequestEntityTooLargeException: la solicitud debe ser menor de 5120 bytes para la operación
UpdateFunctionConfiguration

El tamaño máximo del objeto de variables que se almacena en la configuración de la función no debe
exceder los 4096 bytes. Esto incluye nombres clave, valores, comillas, comas y corchetes. El tamaño total
del cuerpo de la solicitud HTTP también es limitado.

{
"FunctionName": "my-function",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function",
"Runtime": "nodejs12.x",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
"Environment": {
"Variables": {
"BUCKET": "my-bucket",
"KEY": "[Link]"
}
},
...
}

En este ejemplo, el objeto tiene 39 caracteres y ocupa 39 bytes cuando se almacena (sin espacios en
blanco) como la cadena {"BUCKET":"my-bucket","KEY":"[Link]"}. Los caracteres ASCII
estándar en valores de variables de entorno utilizan un byte cada uno. Los caracteres ASCII y Unicode
extendidos pueden usar entre 2 y 4 bytes por carácter.

Error: InvalidParameterValueException: Lambda no pudo configurar las variables de entorno porque las
variables de entorno que ha proporcionado contienen claves reservadas que actualmente no se admiten
para su modificación.

Lambda reserva algunas claves de variables de entorno para uso interno. Por ejemplo, el motor de
ejecución usa AWS_REGION para determinar la región actual y no se puede reemplazar. Otras variables,
como PATH, son usadas por el tiempo de ejecución, pero se pueden extender en la configuración de su
función. Para obtener una lista completa, consulte Variables de entorno de tiempo de ejecución (p. 56).

Solucionar problemas de invocación en AWS

Lambda
Cuando invoca una función de Lambda, Lambda valida la solicitud y comprueba la capacidad de escalado
antes de enviar el evento a su función o, para la invocación asíncrona, a la cola de eventos. Los errores
de invocación pueden deberse a problemas con los parámetros de solicitud, la estructura de eventos, la
configuración de funciones, los permisos de usuario, los permisos de recursos o los límites.

Si invoca su función directamente, verá errores de invocación en la respuesta de Lambda. Si invoca

la función de forma asíncrona, con una asignación de origen de eventos o a través de otro servicio, es
posible que encuentre errores en los registros, una cola de mensajes fallidos o un destino de evento fallido.

428
 AWS Lambda Guía para desarrolladores
Invocación

Las opciones de manejo de errores y el comportamiento de reintento varían en función de cómo invoque
su función y del tipo de error.

Para obtener una lista de los tipos de error que puede devolver la operación Invoke, consulte
Invoke (p. 527).

Error: User: arn:aws:iam::123456789012:user/developer is not authorized to perform:

lambda:InvokeFunction on resource: my-function

El usuario de IAM, o el rol que asume el usuario, necesita permiso para invocar una función. Este
requisito también se aplica a las funciones Lambda y a otros recursos informáticos que invocan funciones.
Añada la política administrada AWSLambdaRole o una política personalizada que permita la acción
lambda:InvokeFunction en la función de destino al usuario de IAM.
Note

A diferencia de otras acciones de la API en Lambda, el nombre de la acción en IAM

(lambda:InvokeFunction) no coincide con el nombre de la acción de la API (Invoke) para
invocar una función.

Para obtener más información, consulte Permisos de AWS Lambda (p. 32).

Error: ResourceConflictException: la operación no se puede realizar en este momento. La función se

encuentra actualmente en el siguiente estado: Pendiente

Cuando conecta una función a una VPC en el momento de la creación, la función entra en un estado
Pending mientras Lambda crea interfaces de red elásticas. Durante este tiempo, no puede invocar o
modificar su función. Si conecta su función a una VPC después de la creación, puede invocarla mientras la
actualización esté pendiente, pero no podrá modificar su código o configuración.

Para obtener más información, consulte Monitorización del estado de una función con la API de
Lambda (p. 101).

Problema: Una función está usando toda la concurrencia disponible, causando que otras funciones se
limiten.

Para dividir la concurrencia disponible en una región en grupos, utilice concurrencia reservada (p. 59). La
concurrencia reservada garantiza que una función siempre puede escalar a su concurrencia asignada, y
también que no escalará más allá de su concurrencia asignada.

Problema: puede invocar la función directamente, pero esta no se ejecuta cuando otro servicio o cuenta la
invoca.

Puede conceder permisos a otros servicios (p. 153) y cuentas para invocar una función en la política
basada en recursos (p. 36) de la función. Si el usuario que invoca la función está en otra cuenta, ese
usuario también necesita permiso para invocar funciones (p. 41).

Problema: la función se invoca continuamente en bucle.

Esto suele ocurrir cuando la función administra recursos en el mismo servicio de AWS que lo activa. Por
ejemplo, es posible crear una función que almacene un objeto en un bucket de Amazon S3 configurado
con una notificación que invoca la función de nuevo (p. 254). Para detener la ejecución de la función, elija
Throttle (Restricción) en la página de configuración de la función (p. 52). A continuación, identifique la ruta
de acceso del código o el error de configuración que provocó la invocación recursiva.

Error: KMSDisabledException: Lambda no pudo descifrar las variables de entorno porque la clave KMS
utilizada está deshabilitada. Compruebe la configuración de teclas KMS de la función.

Este error puede producirse si su clave KMS está deshabilitada o si se revoca la concesión que permite
a Lambda usar la clave. Si falta la concesión, configure la función para usar una clave diferente. A
continuación, reasigne la clave personalizada para volver a crear la concesión.

429
 AWS Lambda Guía para desarrolladores
Ejecución

Solucionar problemas de ejecución en AWS

Lambda
Cuando el motor de ejecución de Lambda ejecuta el código de función, es posible que el evento se
procese en una instancia de la función que ha estado procesando eventos durante algún tiempo, o que
requiera que se inicialice una nueva instancia. Pueden producirse errores cuando durante la inicialización
de la función, cuando el código de controlador procesa el evento o cuando la función devuelve (o no
devuelve) una respuesta.

Los errores de ejecución de funciones pueden deberse a problemas con el código, la configuración de
funciones, los recursos descendentes o los permisos. Si invoca su función directamente, verá errores
de función en la respuesta de Lambda. Si invoca la función de forma asíncrona, con una asignación de
origen de eventos o a través de otro servicio, es posible que encuentre errores en los registros, una cola de
mensajes fallidos o un destino en caso de error. Las opciones de manejo de errores y el comportamiento
de reintento varían en función de cómo invoque su función y del tipo de error.

Cuando el código de función o el tiempo de ejecución de Lambda devuelven un error, el código de estado
en la respuesta de Lambda es 200 OK. La presencia de un error en la respuesta se indica mediante un
encabezado llamado X-Amz-Function-Error. Los códigos de estado de las series 400 y 500 están
reservados para los errores de invocación (p. 428).

Problema: la ejecución de la función tarda demasiado tiempo.

Si el código tarda mucho más en ejecutarse en Lambda que en el equipo local, puede estar limitado por
la memoria o la potencia de procesamiento disponibles para la función. Configure la función con memoria
adicional (p. 52) para aumentar la memoria y la CPU.

Problema: los registros no aparecen en CloudWatch Logs.

Problema: los registros de seguimiento no aparecen en AWS X-Ray.

La función necesita permiso para llamar a CloudWatch Logs y X-Ray. Actualice su rol de ejecución (p. 32)
para concederle permiso. Añada las siguientes políticas administradas para habilitar los registros y el
seguimiento.

• AWSLambdaBasicExecutionRole
• AWSXRayDaemonWriteAccess

Cuando añade permisos a su función, actualice también su código o configuración. Esto obliga a las
instancias en ejecución de su función, cuyas credenciales han expirado, a detenerse y ser sustituidas.

Problema: ([Link]) La función se devuelve antes de que el código termine de ejecutarse

Muchas bibliotecas, incluida la SDK de AWS, funcionan de forma asíncrona. Cuando realiza una llamada
de red o realiza otra operación que requiere esperar una respuesta, las bibliotecas devuelven un objeto
denominado promesa que realiza un seguimiento del progreso de la operación en segundo plano.

Para esperar a que la promesa se resuelva en una respuesta, utilice la palabra clave await. Esto bloquea
la ejecución de su código de controlador hasta que la promesa se resuelve en un objeto que contiene
la respuesta. Si no necesita usar los datos de la respuesta en su código, puede devolver la promesa
directamente al tiempo de ejecución.

Algunas bibliotecas no devuelven promesas, pero se pueden envolver en código que sí lo hace. Para
obtener más información, consulte Controlador de la función AWS Lambda en [Link] (p. 290).

Problema: El SDK de AWS incluido en el tiempo de ejecución no es la versión más reciente

430
 AWS Lambda Guía para desarrolladores
Redes

Problema: El SDK de AWS incluido en el tiempo de ejecución se actualiza automáticamente

Los tiempos de ejecución de los lenguajes de scripting incluyen AWS SDK y se actualizan periódicamente
a la versión más reciente. La versión actual de cada motor de ejecución se muestra en la página de
tiempos de ejecución (p. 118). Para utilizar una versión más reciente del SDK de AWS o para bloquear las
funciones a una versión específica, puede agrupar la biblioteca con el código de función o crear una capa
de Lambda (p. 74). Para obtener información detallada sobre la creación de un paquete de implementación
con dependencias, consulte los temas siguientes:

• Paquete de implementación AWS Lambda en [Link] (p. 292)

• Paquete de implementación de AWS Lambda en Python (p. 304)
• Paquete de implementación de AWS Lambda en Ruby (p. 319)
• Paquete de implementación AWS Lambda en Java (p. 329)
• AWS Lambda Paquete de implementación en Go (p. 359)
• AWS Lambda Paquete de implementación en C# (p. 372)
• AWS Lambda Paquete de implementación en PowerShell (p. 391)

Problema: (Python) Algunas bibliotecas no se cargan correctamente desde el paquete de implementación

Las bibliotecas con módulos de extensión escritos en C o C++ deben compilarse en un entorno con la
misma arquitectura de procesador que Lambda (Amazon Linux). Para obtener más información, consulte
Paquete de implementación de AWS Lambda en Python (p. 304).

Solucionar problemas de redes en AWS Lambda

De forma predeterminada, Lambda ejecuta sus funciones en una nube privada virtual (VPC) interna con
conectividad a los servicios de AWS e Internet. Para acceder a los recursos de red local, puede configurar
la función para que se conecte a una VPC de la cuenta (p. 78). Cuando utiliza esta característica,
administra el acceso a Internet y la conectividad de red de la función con recursos de VPC.

Los errores de conectividad de red pueden deberse a problemas de configuración de enrutamiento, reglas
de grupo de seguridad, permisos de rol, traducción de direcciones de red o disponibilidad de recursos
como direcciones IP o interfaces de red. Pueden dar lugar a un error específico o, si una solicitud no puede
alcanzar su destino, a un tiempo de espera.

Problema: La función pierde el acceso a Internet después de conectarse a una VPC

Error: Error: Connect ETIMEDOUT [Link]:443

Error: Error: Tiempo de espera de la tarea agotado tras 10,00 segundos

Cuando conecta una función a una VPC, todas las solicitudes salientes pasan por la VPC. Para conectarse
a Internet, configure la VPC para que envíe tráfico saliente desde la subred de la función a una puerta de
enlace NAT en una subred pública. Para obtener más información y ejemplos de configuraciones de VPC,
consulte Acceso a Internet y a los servicios para funciones conectadas a la VPC (p. 80).

Problema: La función necesita acceso a los servicios de AWS sin utilizar internet

Para conectarse a servicios de AWS desde una subred privada sin acceso a Internet, utilice los puntos de
enlace de la VPC. Para obtener una plantilla de ejemplo con extremos de VPC para DynamoDB y Amazon
S3, consulte ??? (p. 81).

Error: ENILimitReacedException: Se alcanzó el límite de interfaz de red elástica para la VPC de la función.

Al conectar una función a una VPC, Lambda crea una interfaz de red elástica para cada combinación
de subred y grupo de seguridad asociados a la función. Estas interfaces de red están limitadas a 250

431
 AWS Lambda Guía para desarrolladores
Redes

por VPC, pero este límite puede aumentarse. Para solicitar un aumento, utilice la consola del Centro de
soporte.

432
 AWS Lambda Guía para desarrolladores

Versiones de AWS Lambda

En la siguiente tabla, se describen los cambios importantes que se han realizado en la Guía para
desarrolladores de AWS Lambda después de mayo de 2018. Para obtener notificaciones sobre las
actualizaciones de esta documentación, suscríbase a la fuente RSS.

update-history-change update-history-description update-history-date

Compatibilidad con las API HTTP Se ha actualizado y ampliado la March 23, 2020
de API Gateway documentación sobre el uso de
Lambda con API Gateway, como
la compatibilidad con las API
HTTP. Se ha incorporado una
aplicación de ejemplo que crea
una API y una función con AWS
CloudFormation. Para obtener
más información, consulte Uso
de AWS Lambda con Amazon
API Gateway.

Ruby 2.7 Hay un nuevo tiempo de February 19, 2020

ejecución disponible para Ruby
2.7, ruby2.7, que es el primer
tiempo de ejecución de Ruby
al usar Amazon Linux 2. Para
obtener más información,
consulte Creación de funciones
Lambda con Ruby.

Métricas de simultaneidad Ahora AWS Lambda February 18, 2020

informa de la métrica
ConcurrentExecutions
para todas las funciones, alias y
versiones. Puede ver un gráfico
para esta métrica en la página
de supervisión de su función.
Anteriormente, sólo se informó
de ConcurrentExecutions
en el nivel de cuenta y para
las funciones que utilizan
concurrencia reservada. Para
obtener más detalles, consulte
Métricas de función de AWS
Lambda.

Actualizar a estados de función Los estados de función se January 24, 2020

aplican ahora para todas
las funciones de forma
predeterminada. Al conectar
una función a una VPC, Lambda
crea interfaces de red elásticas
compartidas. Esto permite que
su función se escale sin crear
interfaces de red adicionales.
Durante este tiempo, no puede

433
 AWS Lambda Guía para desarrolladores

realizar operaciones adicionales

en la función, incluida la
actualización de su configuración
y la publicación de versiones.
En algunos casos, la invocación
también se ve afectada. Los
detalles sobre el estado actual de
una función están disponibles en
la API de Lambda.

Esta actualización se está

publicando en fases. Para
obtener más información,
consulte el ciclo de vida
actualizado de los estados de
Lambda para redes de VPC en
el blog de informática de AWS.
Para obtener más información
acerca de los estados, consulte
Estados de función de AWS
Lambda.

Actualizaciones a la salida Se han agregado códigos de January 20, 2020

de la API de configuración de motivo a StateReasOnCode
funciones (InvalidSubnet,
InvalidSecurityGroup) y
LastUpdateStatusReasonCode
(SubNetOutOutOFIPAddresses,
InvalidSubnet,
InvalidSecurityGroup) para las
funciones que se conectan a
una VPC. Para obtener más
información acerca de los
estados, consulte Estados de
función de AWS Lambda.

Simultaneidad aprovisionada Ahora puede asignar December 3, 2019

simultaneidad aprovisionada para
una versión o alias de función.
La simultaneidad aprovisionada
permite que una función escale
sin fluctuaciones en la latencia.
Para obtener más detalles,
consulte Administración de la
simultaneidad de una función
Lambda.

434
 AWS Lambda Guía para desarrolladores

Crear un proxy de base de datos Ahora puede usar la consola December 3, 2019
de Lambda para crear un proxy
de base de datos para una
función Lambda. Un proxy de
base de datos permite que una
función alcance altos niveles
de simultaneidad sin agotar las
conexiones de base de datos.
Para obtener más información,
consulte Configuración del
acceso a la base de datos para
una función Lambda.

Compatibilidad con percentiles Ahora puede filtrar la métrica November 26, 2019
para la métrica de duración de duración en función de los
percentiles. Para obtener más
información, consulte Métricas de
AWS Lambda.

Opciones de gestión de errores Hay disponibles nuevas opciones November 25, 2019
para la invocación asincrónica de configuración para la
invocación asincrónica. Puede
configurar Lambda para limitar
los reintentos y establecer una
antigüedad de evento máxima.
Para obtener más información,
consulte Configuración de
la gestión de errores para la
invocación asincrónica.

Gestión de errores para orígenes Hay disponibles nuevas opciones November 25, 2019
de eventos de flujo de configuración para los
mapeos de origen de eventos
que se leen de los flujos. Puede
configurar los mapeos de
orígenes de eventos de flujos
de DynamoDB y de flujos de
Kinesis para limitar los reintentos
y establecer una antigüedad
de registro máxima. Cuando
se producen errores, puede
configurar el mapeo de origen de
eventos para que divida los lotes
antes de volver a intentarlo y
envíe registros de invocación de
los lotes con error a una cola o
tema. Para obtener más detalles,
consulte Mapeo de orígenes de
eventos de AWS Lambda.

435
 AWS Lambda Guía para desarrolladores

Estados de función Al crear o actualizar una función, November 25, 2019

esta cambia a un estado
pendiente mientras Lambda
aprovisiona recursos para
admitirla. Si conecta su función
a una VPC, Lambda puede
crear una interfaz de red elástica
compartida de inmediato, en
lugar de crear interfaces de red
cuando se invoca la función.
Esto da como resultado un mejor
rendimiento para las funciones
conectadas a la VPC, pero podría
requerir una actualización de
la automatización. Consulte
Estados de función de AWS
Lambda para obtener más
detalles.

Destinos para invocación Ahora puede configurar Lambda November 25, 2019
asincrónica para que envíe registros de
invocaciones asincrónicas a
otro servicio. Los registros de
invocación contienen detalles
sobre el evento, el contexto y la
respuesta de la función. Puede
enviar registros de invocación
a una cola SQS, un tema SNS,
una función Lambda o un bus
de eventos de EventBridge.
Para obtener más información,
consulte Configuración de
destinos para invocación
asincrónica.

Aumento de la simultaneidad Una nueva opción para mapeos November 25, 2019
para orígenes de eventos de flujo de orígenes de eventos de flujos
de DynamoDB y de flujos de
Kinesis le permiten procesar
más de un lote a la vez de cada
fragmento. Cuando aumenta el
número de lotes simultáneos
por fragmento, la simultaneidad
de su función puede ser hasta
diez veces mayor que el número
de fragmentos en el flujo. Para
obtener más detalles, consulte
Mapeo de orígenes de eventos
de AWS Lambda.

Nuevos tiempos de ejecución Hay nuevos tiempos de ejecución November 18, 2019
para [Link], Python y Java disponibles para [Link] 12,
Python 3.8 y Java 11. Para
obtener más información,
consulte Tiempos de ejecución
de AWS Lambda.

436
 AWS Lambda Guía para desarrolladores

Compatibilidad de la cola FIFO Ahora puede crear un mapeo November 18, 2019
con los orígenes de eventos de de orígenes de eventos que
Amazon SQS haga lecturas desde una cola
de primero en entrar, primero
en salir (FIFO). Antes, solo
se admitían colas estándar.
Para obtener más información,
consulte Uso de AWS Lambda
con Amazon SQS.

Creación de aplicaciones en la La creación de aplicaciones en October 31, 2019

consola de Lambda la consola de Lambda ya está
disponible en general. Para
obtener instrucciones, consulte
Creación de una aplicación con
entrega continua en la consola
de Lambda.

Creación de aplicaciones en la Ahora puede crear una aplicación October 3, 2019

consola de Lambda (beta) de Lambda con una canalización
de entrega continua integrada
en la consola de Lambda. La
consola proporciona aplicaciones
de ejemplo que puede utilizar
como punto de partida para su
propio proyecto. Elija entre AWS
CodeCommit y GitHub para
el control de origen. Cada vez
que se introducen cambios en
el repositorio, la canalización
incluida se genera e implementa
automáticamente. Para obtener
instrucciones, consulte Creación
de una aplicación con entrega
continua en la consola de
Lambda.

Mejoras de rendimiento para Lambda utiliza ahora un nuevo September 3, 2019

funciones conectadas a una VPC tipo de interfaz de red elástica
que comparten todas las
funciones en una subred de
nube virtual privada (VPC). Al
conectar una función a una VPC,
Lambda crea una interfaz de
red para cada combinación de
grupo de seguridad y subred
que elija. Cuando las interfaces
de red compartidas están
disponibles, la función ya no
tiene que crear interfaces de red
adicionales conforme se escala.
Esto mejora drásticamente los
tiempos de inicio. Para obtener
más información, consulte
Configuración de una función
Lambda para obtener acceso a
los recursos en una VPC.

437
 AWS Lambda Guía para desarrolladores

Configuración de lotes de Ahora puede configurar una August 29, 2019

transmisión ventana de lote para las
asignaciones de orígenes de
eventos de Amazon DynamoDB
y Amazon Kinesis. Puede
configurar una ventana de
lote de hasta cinco minutos
para almacenar los registros
entrantes hasta completar un
lote. Esto reduce el número de
invocaciones a la función cuando
el flujo se encuentra menos
activo.

Integración de la información de La página de monitorización de la June 18, 2019

CloudWatch Logs consola de Lambda ahora incluye
informes de Amazon CloudWatch
Logs Insights. Para obtener más
información, consulte Funciones
de monitorización en la consola
de AWS Lambda.

Amazon Linux 2018.03 El entorno de ejecución de May 21, 2019

Lambda se está actualizando
para utilizar Amazon Linux
2018.03. Para obtener más
información, consulte Entorno de
ejecución.

[Link] Hay un nuevo runtime disponible May 13, 2019

para [Link] 10, nodejs10.x.
Este runtime utiliza [Link] 10.15
y se actualizará con la última
versión secundaria de [Link]
10 periódicamente. [Link] 10
es también el primer runtime
que utiliza Amazon Linux 2.
Para obtener más información,
consulte Creación de funciones
Lambda con [Link].

GetLayerVersionByArn API Utilice la API April 25, 2019

GetLayerVersionByArn
para descargar información
de la versión de capa con
el ARN de versión como
entrada. En comparación
con GetLayerVersion,
GetLayerVersionByArn le permite
utilizar el ARN directamente en
lugar de analizarlo para obtener
el nombre de la capa y el número
de versión.

438
 AWS Lambda Guía para desarrolladores

Runtimes personalizados Cree un tiempo de ejecución November 29, 2018

personalizado para ejecutar
funciones de Lambda en su
lenguaje de programación
preferido. Para obtener más
información, consulte Runtimes
de AWS Lambda personalizados.

Ruby AWS Lambda ahora admite November 29, 2018

Ruby 2.5 con un nuevo runtime.
Para obtener más información,
consulte Creación de funciones
Lambda con Ruby.

Desencadenadores de Elastic Load Balancing ahora November 29, 2018

balanceadores de carga de es compatible con funciones
aplicaciones Lambda como destino de
Application Load Balancers.
Para obtener más información,
consulte Uso de Lambda con
balanceadores de carga de
aplicaciones.

Capas Con las capas de Lambda, puede November 29, 2018

empaquetar e implementar
bibliotecas, tiempos de
ejecución personalizados y
otras dependencias de forma
independiente del código de la
función. Comparta sus capas
con sus otras cuentas o todo
el mundo. Para obtener más
información, consulte Capas de
AWS Lambda.

Uso de los consumidores de Puede utilizar los consumidores November 19, 2018
flujos HTTP/2 de Kinesis como de flujos de datos HTTP/2 de
desencadenadores Kinesis para enviar eventos a
AWS Lambda. Los consumidores
de flujos tienen rendimiento de
lectura dedicado desde cada
partición del flujo de datos y
utilizan HTTP/2 para minimizar
la latencia. Para obtener más
información, consulte Uso de
AWS Lambda con Kinesis.

Python 3.7 AWS Lambda ahora es November 19, 2018

compatible con Python 3.7 con
un nuevo tiempo de ejecución.
Para obtener más información,
consulte Creación de funciones
de Lambda con Python.

439
 AWS Lambda Guía para desarrolladores

Incremento del límite de carga El tamaño de carga máximo para November 16, 2018
para las invocaciones asíncronas las invocaciones asíncronas
de funciones ha aumentado de 128 KB a
256 KB, que coincide con el
tamaño máximo del mensaje
desde un desencadenador de
Amazon SNS. Para obtener más
información, consulte Límites de
AWS Lambda.

Región AWS GovCloud (EE. UU. AWS Lambda ya está disponible November 12, 2018
Este) en la región AWS GovCloud
([Link]. Este). Para obtener
más información, consulte AWS
GovCloud (US-East) Now Open
en el blog de AWS.

Contenido trasladado a la nueva Algunos contenidos se centraban October 25, 2018

Guía para desarrolladores de en la creación de aplicaciones
AWS SAM. sin servidor usando el Modelo de
aplicación sin servidor de AWS
(AWS SAM). Estos contenidos
se han trasladado a Guía para
desarrolladores de Modelo de
aplicación sin servidor de AWS.

Visualización de aplicaciones de Puede ver el estado de sus October 11, 2018

Lambda en la consola aplicaciones de Lambda
en la página Applications
(Aplicaciones) en la consola de
Lambda. Esta página muestra
el estado de la pila de AWS
CloudFormation. Incluye enlaces
a páginas donde puede ver
más información acerca de los
recursos de la pila. También
puede ver métricas acumuladas
para la aplicación y crear
paneles de monitorización
personalizados.

Límite de tiempo de espera de Para permitir las funciones October 10, 2018
ejecución de funciones de ejecución prolongada, el
máximo tiempo de espera de
ejecución configurable se ha
aumentado de 5 minutos a 15
minutos. Para obtener más
información, consulte Límites de
AWS Lambda.

Compatibilidad con lenguaje AWS Lambda ahora admite el September 11, 2018
de PowerShell Core en AWS lenguaje de PowerShell Core.
Lambda Para obtener más información,
consulte Creación de funciones
de Lambda con PowerShell.

440
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Compatibilidad con el tiempo de AWS Lambda ahora admite el July 9, 2018

ejecución. de NET Core 2.1.0 en tiempo de ejecución de .NET
AWS Lambda Core 2.1.0. Para obtener más
información, consulte CLI
de .NET Core.

Actualizaciones ahora Ahora puede suscribirse a July 5, 2018

disponibles sobre RSS una fuente RSS para recibir
notificaciones de la Guía para
desarrolladores de AWS Lambda.

Región China (Ningxia) AWS Lambda ya está disponible June 28, 2018
en la Región China (Ningxia).
Para obtener más información
acerca de las regiones y los
puntos de enlace de Lambda,
consulte Regiones y puntos
de enlace en la AWS General
Reference.

Compatibilidad con Amazon SQS AWS Lambda ahora admite June 28, 2018
como origen de eventos Amazon Simple Queue Service
(Amazon SQS) como origen
de eventos. Para obtener más
información, consulte Invocación
de funciones de Lambda.

Actualizaciones anteriores
En la siguiente tabla, se describen los cambios importantes que se han realizado en cada una de las
versiones de la Guía para desarrolladores de AWS Lambda anteriores a junio de 2018.

Cambio Descripción Fecha

Compatibilidad con AWS Lambda ahora es compatible con la versión 8.10 2 de abril
tiempo de ejecución 8.10 de tiempo de ejecución de [Link]. Para obtener más de 2018
de [Link] información, consulte Creación de funciones de Lambda con
[Link] (p. 289).

ID de revisión de los AWS Lambda admite ahora los ID de revisión en los alias 25 de
alias y las funciones y las versiones de las funciones. Puede usar estos ID para enero de
realizar un seguimiento de las actualizaciones condicionales 2018
y aplicarlas al actualizar los recursos de alias o la versión de
función.

Soporte del tiempo AWS Lambda ha agregado compatibilidad del tiempo de 15 de

de ejecución para Go ejecución para Go y .NET 2.0. Para obtener más información, enero de
y .NET 2.0 consulte Creación de funciones de Lambda con Go (p. 359) y 2018
Creación de funciones de Lambda con C# (p. 372).

Rediseño de la consola AWS Lambda presenta una nueva consola de Lambda para 30 de
simplificar su experiencia y se ha añadido un Cloud9 Code noviembre
Editor para mejorar su capacidad de depurar y revisar el código de 2017
de las funciones. Para obtener más información, consulte
Creación de funciones mediante el editor de la consola de AWS
Lambda (p. 6).

441
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha

Definición de límites de AWS Lambda admite ahora la definición de límites de 30 de

simultaneidad para cada simultaneidad para cada función. Para obtener más noviembre
función información, consulte Administración de la simultaneidad para de 2017
una función Lambda (p. 59).

Desvío de tráfico AWS Lambda admite ahora el desvío de tráfico con alias. Para 28 de
mediante alias obtener más información, consulte Implementaciones continuas noviembre
para funciones de Lambda (p. 145). de 2017

Implementación de AWS Lambda permite ahora implementar de forma segura 28 de

código gradual nuevas versiones de su función de Lambda utilizando noviembre
Code Deploy. Para obtener más información, consulte de 2017
Implementación de código gradual.

Región China (Pekín) AWS Lambda ya está disponible en la Región China (Pekín). 9 de
Para obtener más información acerca de las regiones y los noviembre
puntos de enlace de Lambda, consulte Regiones y puntos de de 2017
enlace en la AWS General Reference.

Presentación de SAM AWS Lambda presenta SAM Local (denominado también 11 de

Local SAM CLI), una herramienta de la AWS CLI que proporciona agosto de
un entorno para desarrollar, probar y analizar localmente 2017
aplicaciones sin servidor antes de cargarlas en el motor de
tiempo de ejecución de Lambda. Para obtener más información,
consulte el tema relacionado con la prueba y depuración de
aplicaciones sin servidor.

Región Canadá (Central) AWS Lambda ya está disponible en la Región Canadá 22 de junio
(Central). Para obtener más información acerca de las regiones de 2017
y los puntos de enlace de Lambda, consulte Regiones y puntos
de enlace en la AWS General Reference.

Región América del Sur AWS Lambda ya está disponible en la Región América del 6 de junio
(São Paulo) Sur (São Paulo). Para obtener más información acerca de las de 2017
regiones y los puntos de enlace de Lambda, consulte Regiones
y puntos de enlace en la AWS General Reference.

Compatibilidad de AWS Lambda introduce la compatibilidad con X-Ray, que permite 19 de abril
Lambda para AWS X- detectar, analizar y optimizar problemas de desempeño con de 2017
Ray. las aplicaciones de Lambda. Para obtener más información,
consulte Uso de AWS X-Ray (p. 404).

Región Asia Pacífico AWS Lambda ya está disponible en la Región Asia Pacífico 28 de
(Mumbai) (Mumbai). Para obtener más información acerca de las marzo de
regiones y los puntos de enlace de Lambda, consulte Regiones 2017
y puntos de enlace en la AWS General Reference.

AWS Lambda ahora es AWS Lambda ha agregado compatibilidad con el tiempo 22 de

compatible con el tiempo de ejecución v6.10 de [Link]. Para obtener más marzo de
de ejecución v6.10 de información, consulte Creación de funciones de Lambda con 2017
[Link] [Link] (p. 289).

Región de Europa AWS Lambda ya está disponible en la Región de Europa 1 de

(Londres) (Londres). Para obtener más información acerca de las febrero de
regiones y los puntos de enlace de Lambda, consulte Regiones 2017
y puntos de enlace en la AWS General Reference.

442
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha

Compatibilidad de AWS AWS Lambda incorpora compatibilidad con C#. Para obtener 3 de
Lambda con el tiempo más información, consulte Creación de funciones de Lambda diciembre
de ejecución de .NET, con C# (p. 372). de 2016
Lambda@Edge (vista
previa), las colas de Lambda@Edge le permite ejecutar funciones de Lambda en
mensajes fallidos y las ubicaciones de borde de AWS en respuesta a eventos de
la implementación CloudFront. Para obtener más información, consulte Uso de
automatizada de las AWS Lambda con CloudFront Lambda@Edge (p. 193).
aplicaciones sin servidor

AWS Lambda agrega Con Lambda y Amazon Lex, puede crear rápidamente bots 30 de
Amazon Lex como de chat para diversos servicios, como Slack y Facebook. Para noviembre
origen de eventos obtener más información, consulte Uso de AWS Lambda con de 2016
compatible. Amazon Lex (p. 249).

[Link]. Oeste (Norte de AWS Lambda ya está disponible en la [Link]. Oeste (Norte 21 de
California) de California). Para obtener más información acerca de las noviembre
regiones y los puntos de enlace de Lambda, consulte Regiones de 2016
y puntos de enlace en la AWS General Reference.

Se presenta AWS AWS Serverless Application Model: ahora puede utilizar AWS 18 de
Serverless Application SAM para definir la sintaxis para expresar recursos dentro de noviembre
Model, que permite una aplicación sin servidor. Para implementar la aplicación, de 2016
crear e implementar solo tiene que especificar los recursos que necesita que formen
aplicaciones basadas parte de ella, junto con sus políticas de permisos asociadas
en Lambda y utilizar en un archivo de plantilla de AWS CloudFormation (escrito en
variables de entorno JSON o YAML), empaquetar sus artefactos de implementación
para los ajustes de e implementar la plantilla. Para obtener más información,
configuración de las consulte Aplicaciones de AWS Lambda (p. 132).
funciones de Lambda.
Variables de entorno: puede utilizar variables de entorno para
especificar las opciones de configuración de una función de
Lambda fuera del código de la función. Para obtener más
información, consulte Uso de variables de entorno de AWS
Lambda (p. 54).

Región Asia Pacífico AWS Lambda ya está disponible en la Región Asia Pacífico 29 de
(Seúl) (Seúl). Para obtener más información acerca de las regiones y agosto de
los puntos de enlace de Lambda, consulte Regiones y puntos 2016
de enlace en la AWS General Reference.

Región Asia Pacífico Lambda ya está disponible en la Región Asia Pacífico (Sídney). 23 de junio
(Sídney) Para obtener más información acerca de las regiones y los de 2016
puntos de enlace de Lambda, consulte Regiones y puntos de
enlace en la AWS General Reference.

Actualizaciones de la La consola de Lambda se ha actualizado para simplificar el 23 de junio

consola de Lambda proceso de creación de roles. Para obtener más información, de 2016
consulte Creación de una función de Lambda con la
consola (p. 3).

AWS Lambda ahora es AWS Lambda ha agregado compatibilidad con el tiempo 07 de abril
compatible con el tiempo de ejecución v4.3. Para obtener más información, consulte de 2016
de ejecución v4.3 de Creación de funciones de Lambda con [Link] (p. 289).
[Link]

443
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha

Región Europa Lambda ya está disponible en la región Europa (Fráncfort). 14 de

(Fráncfort) Para obtener más información acerca de las regiones y los marzo de
puntos de enlace de Lambda, consulte Regiones y puntos de 2016
enlace en la AWS General Reference.

Compatibilidad con VPC Ahora puede configurar una función de Lambda para obtener 11 de
acceso a los recursos de una VPC. Para obtener más febrero de
información, consulte Configuración de una función Lambda 2016
para obtener acceso a los recursos en una VPC (p. 78).

Se ha actualizado el El entorno de ejecución (p. 118) se ha actualizado. 4 de

tiempo de ejecución de noviembre
AWS Lambda. de 2015

Compatibilidad con el Ahora puede desarrollar el código de las funciones de Lambda 08 de

control de versiones, con Python. Para obtener más información, consulte Creación octubre de
Python para desarrollar de funciones de Lambda con Python (p. 302). 2015
código para las
funciones de Lambda, Control de versiones: puede mantener una o varias versiones
eventos programados y de una función de Lambda. El control de versiones permite
aumento del tiempo de controlar qué versión de una función de Lambda se ejecuta
ejecución en los distintos entornos (por ejemplo, desarrollo, pruebas, o
producción). Para obtener más información, consulte Versiones
de funciones de AWS Lambda (p. 68).

Eventos programados: también puede configurar AWS Lambda

para que invoque el código de forma periódica y programada
utilizando la consola de AWS Lambda. Puede especificar una
frecuencia fija (un número de horas, días o semanas) o una
expresión cron. Para ver un ejemplo, consulte Uso de AWS
Lambda con Amazon CloudWatch Events (p. 185).

Aumento del tiempo de ejecución: a partir de ahora, puede

configurar las funciones de Lambda para que se ejecuten
durante un máximo de cinco minutos, lo que permite utilizar
funciones con tiempos de ejecución más largos como, por
ejemplo, trabajos de adquisición y procesamiento de grandes
volúmenes de datos.

Compatibilidad con DynamoDB Streams ya está disponible con carácter general 14 de julio
DynamoDB Streams y se puede utilizar en todas las regiones en las que está de 2015
disponible. Puede activar DynamoDB Streams para una tabla
y utilizar una función de Lambda como un disparador para la
tabla. Los disparadores son acciones personalizadas que se
llevan a cabo en respuesta a las actualizaciones realizadas
en la tabla de DynamoDB. Para ver un tutorial de ejemplo,
consulte Tutorial: Usar de AWS Lambda con flujos de Amazon
DynamoDB. (p. 210).

444
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha

AWS Lambda ahora Hasta ahora, para invocar una función de Lambda desde 09 de julio
permite invocar aplicaciones web, móviles o IoT, se necesitaban los SDK de de 2015
funciones de Lambda AWS (por ejemplo, AWS SDK para Java, AWS SDK para
con clientes compatibles Android o AWS SDK para iOS). Ahora, AWS Lambda permite
con REST. invocar una función de Lambda con clientes compatibles con
REST a través de una API personalizada que puede crear con
Amazon API Gateway. Puede enviar solicitudes a la URL del
punto de enlace de una función de Lambda. Puede configurar
la seguridad en el punto de enlace para permitir el acceso
libre, utilizar AWS Identity and Access Management (IAM)
para autorizar el acceso, o utilizar claves de API para medir el
acceso de otros usuarios a sus funciones de Lambda.

Para ver un ejemplo de ejercicio de introducción, consulte Uso

de AWS Lambda con Amazon API Gateway (p. 157).

Para obtener más información sobre Amazon API Gateway,

consulte [Link]

La consola de AWS La consola de AWS Lambda proporciona un conjunto de 09 de julio

Lambda ahora ofrece proyectos. Cada proyecto ofrece una configuración de origen de 2015
proyectos para crear de eventos de muestra y código de muestra para la función de
fácilmente funciones de Lambda que puede utilizar para crear fácilmente aplicaciones
Lambda y probarlas. basadas en Lambda. Ahora, todos los ejercicios de introducción
de AWS Lambda utilizan proyectos. Para obtener más
información, consulte Introducción a AWS Lambda (p. 3).

AWS Lambda ahora A partir de ahora, puede escribir el código de Lambda en Java. 15 de junio
permite utilizar Java Para obtener más información, consulte Creación de funciones de 2015
para crear funciones de de Lambda con Java (p. 328).
Lambda.

AWS Lambda ahora Puede cargar el paquete de implementación ([Link]) de 28 de mayo

permite especificar un una función de Lambda en un bucket de Amazon S3 de la de 2015
objeto de Amazon S3 misma región en la que desea crear la función de Lambda.
como archivo .zip de A continuación, puede especificar el nombre del bucket y un
la función al crear o nombre de la clave de objeto al crear o actualizar una función
actualizar una función de de Lambda.
Lambda.

445
 AWS Lambda Guía para desarrolladores
Actualizaciones anteriores

Cambio Descripción Fecha

AWS Lambda ahora AWS Lambda ya se encuentra disponible con carácter general 9 de abril
está disponible con para su uso con fines de producción. La versión también de 2015
carácter general con presenta características nuevas que facilitan la creación de
soporte para backends backends para móviles, tablets e Internet de las cosas (IoT) con
para móviles AWS Lambda que se escalan automáticamente sin necesidad
de aprovisionar ni administrar infraestructura. AWS Lambda
ahora es compatible con eventos en tiempo real (síncronos) y
asíncronos. También incluye una configuración y administración
de orígenes de eventos más sencilla. El modelo de permisos
y el modelo de programación se han simplificado mediante
la introducción de políticas de recursos para las funciones de
Lambda.

La documentación se ha actualizado en consecuencia. Para

obtener información, consulte los siguientes temas:

Introducción a AWS Lambda (p. 3)

AWS Lambda

Versión de prueba Versión de prueba de la Guía para desarrolladores de AWS 13 de

Lambda. noviembre
de 2014

446
 AWS Lambda Guía para desarrolladores
Actions

Referencia de la API
Esta sección contiene la documentación de referencia de la AWS Lambda. Cuando haga llamadas a la
API, deberá autenticar la solicitud proporcionando una firma. AWS Lambda es compatible con Signature
Version 4. Para obtener más información, consulte Proceso de firma Signature Version 4 en la Referencia
general de Amazon Web Services.

Para obtener información general acerca del servicio, consulte ¿Qué es AWS Lambda? (p. 1).

Puede utilizar la AWS CLI para explorar la API de AWS Lambda. Esta guía proporciona varios tutoriales
que utilizan la AWS CLI.

Temas

• Actions (p. 447)

• Data Types (p. 617)

Actions
The following actions are supported:

• AddLayerVersionPermission (p. 449)

• AddPermission (p. 452)
• CreateAlias (p. 456)
• CreateEventSourceMapping (p. 460)
• CreateFunction (p. 466)
• DeleteAlias (p. 475)
• DeleteEventSourceMapping (p. 477)
• DeleteFunction (p. 481)
• DeleteFunctionConcurrency (p. 483)
• DeleteFunctionEventInvokeConfig (p. 485)
• DeleteLayerVersion (p. 487)
• DeleteProvisionedConcurrencyConfig (p. 489)
• GetAccountSettings (p. 491)
• GetAlias (p. 493)
• GetEventSourceMapping (p. 496)
• GetFunction (p. 500)
• GetFunctionConcurrency (p. 503)
• GetFunctionConfiguration (p. 505)
• GetFunctionEventInvokeConfig (p. 511)
• GetLayerVersion (p. 514)
• GetLayerVersionByArn (p. 517)
• GetLayerVersionPolicy (p. 520)
• GetPolicy (p. 522)
• GetProvisionedConcurrencyConfig (p. 524)
• Invoke (p. 527)

447
 AWS Lambda Guía para desarrolladores
Actions

• InvokeAsync (p. 532)

• ListAliases (p. 534)
• ListEventSourceMappings (p. 537)
• ListFunctionEventInvokeConfigs (p. 540)
• ListFunctions (p. 543)
• ListLayers (p. 546)
• ListLayerVersions (p. 548)
• ListProvisionedConcurrencyConfigs (p. 551)
• ListTags (p. 554)
• ListVersionsByFunction (p. 556)
• PublishLayerVersion (p. 559)
• PublishVersion (p. 563)
• PutFunctionConcurrency (p. 570)
• PutFunctionEventInvokeConfig (p. 573)
• PutProvisionedConcurrencyConfig (p. 577)
• RemoveLayerVersionPermission (p. 580)
• RemovePermission (p. 582)
• TagResource (p. 584)
• UntagResource (p. 586)
• UpdateAlias (p. 588)
• UpdateEventSourceMapping (p. 592)
• UpdateFunctionCode (p. 598)
• UpdateFunctionConfiguration (p. 605)
• UpdateFunctionEventInvokeConfig (p. 614)

448
 AWS Lambda Guía para desarrolladores
AddLayerVersionPermission

AddLayerVersionPermission
Adds permissions to the resource-based policy of a version of an AWS Lambda layer. Use this action to
grant layer usage permission to other accounts. You can grant permission to a single account, all AWS
accounts, or all accounts in an organization.

To revoke permission, call RemoveLayerVersionPermission (p. 580) with the statement ID that you
specified when you added it.

Request Syntax
POST /2018-10-31/layers/LayerName/versions/VersionNumber/policy?RevisionId=RevisionId
HTTP/1.1
Content-type: application/json

{
"Action": "string",
"OrganizationId": "string",
"Principal": "string",
"StatementId": "string"
}

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 449)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
RevisionId (p. 449)

Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a
policy that has changed since you last read it.
VersionNumber (p. 449)

The version number.

Request Body
The request accepts the following data in JSON format.

Action (p. 449)

The API action that grants access to the layer. For example, lambda:GetLayerVersion.

Type: String

Pattern: lambda:GetLayerVersion

Required: Yes
OrganizationId (p. 449)

With the principal set to *, grant permission to all accounts in the specified organization.

449
 AWS Lambda Guía para desarrolladores
AddLayerVersionPermission

Type: String

Pattern: o-[a-z0-9]{10,32}

Required: No
Principal (p. 449)

An account ID, or * to grant permission to all AWS accounts.

Type: String

Pattern: \d{12}|\*|arn:(aws[a-zA-Z-]*):iam::\d{12}:root

Required: Yes
StatementId (p. 449)

An identifier that distinguishes the policy from others on the same layer version.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 100.

Pattern: ([a-zA-Z0-9-_]+)

Required: Yes

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"RevisionId": "string",
"Statement": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

RevisionId (p. 450)

A unique identifier for the current revision of the policy.

Type: String
Statement (p. 450)

The permission statement.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

450
 AWS Lambda Guía para desarrolladores
AddLayerVersionPermission

HTTP Status Code: 400

PolicyLengthExceededException

The permissions policy for the resource is too large. Learn more

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

451
 AWS Lambda Guía para desarrolladores
AddPermission

AddPermission
Grants an AWS service or another account permission to use a function. You can apply the policy at the
function level, or specify a qualifier to restrict access to a single version or alias. If you use a qualifier, the
invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the function.

To grant permission to another account, specify the account ID as the Principal. For AWS
services, the principal is a domain-style identifier defined by the service, like [Link] or
[Link]. For AWS services, you can also specify the ARN of the associated resource as
the SourceArn. If you grant permission to a service principal without specifying the source, other accounts
could potentially configure resources in their account to invoke your Lambda function.

This action adds a statement to a resource-based permissions policy for the function. For more information
about function policies, see Lambda Function Policies.

Request Syntax
POST /2015-03-31/functions/FunctionName/policy?Qualifier=Qualifier HTTP/1.1
Content-type: application/json

{
"Action": "string",
"EventSourceToken": "string",
"Principal": "string",
"RevisionId": "string",
"SourceAccount": "string",
"SourceArn": "string",
"StatementId": "string"
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 452)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 452)

Specify a version or alias to add permissions to a published version of the function.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

452
 AWS Lambda Guía para desarrolladores
AddPermission

Request Body
The request accepts the following data in JSON format.

Action (p. 452)

The action that the principal can use on the function. For example, lambda:InvokeFunction or
lambda:GetFunction.

Type: String

Pattern: (lambda:[*]|lambda:[a-zA-Z]+|[*])

Required: Yes
EventSourceToken (p. 452)

For Alexa Smart Home functions, a token that must be supplied by the invoker.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Pattern: [a-zA-Z0-9._\-]+

Required: No
Principal (p. 452)

The AWS service or account that invokes the function. If you specify a service, use SourceArn or
SourceAccount to limit who can invoke the function through that service.

Type: String

Pattern: .*

Required: Yes
RevisionId (p. 452)

Only update the policy if the revision ID matches the ID that's specified. Use this option to avoid
modifying a policy that has changed since you last read it.

Type: String

Required: No
SourceAccount (p. 452)

For Amazon S3, the ID of the account that owns the resource. Use this together with SourceArn to
ensure that the resource is owned by the specified account. It is possible for an Amazon S3 bucket to
be deleted by its owner and recreated by another account.

Type: String

Pattern: \d{12}

Required: No
SourceArn (p. 452)

For AWS services, the ARN of the AWS resource that invokes the function. For example, an Amazon
S3 bucket or Amazon SNS topic.

453
 AWS Lambda Guía para desarrolladores
AddPermission

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)

Required: No
StatementId (p. 452)

A statement identifier that differentiates the statement from others in the same policy.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 100.

Pattern: ([a-zA-Z0-9-_]+)

Required: Yes

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"Statement": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

Statement (p. 454)

The permission statement that's added to the function policy.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PolicyLengthExceededException

The permissions policy for the resource is too large. Learn more

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

454
 AWS Lambda Guía para desarrolladores
AddPermission

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

455
 AWS Lambda Guía para desarrolladores
CreateAlias

CreateAlias
Creates an alias for a Lambda function version. Use aliases to provide clients with a function identifier that
you can update to invoke a different version.

You can also map an alias to split invocation requests between two versions. Use the RoutingConfig
parameter to specify a second version and the percentage of invocation requests that it receives.

Request Syntax
POST /2015-03-31/functions/FunctionName/aliases HTTP/1.1
Content-type: application/json

{
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 456)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

Description (p. 456)

A description of the alias.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

456
 AWS Lambda Guía para desarrolladores
CreateAlias

Required: No
FunctionVersion (p. 456)

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)

Required: Yes
Name (p. 456)

The name of the alias.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)

Required: Yes
RoutingConfig (p. 456)

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

Required: No

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"AliasArn": "string",
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RevisionId": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

AliasArn (p. 457)

The Amazon Resource Name (ARN) of the alias.

457
 AWS Lambda Guía para desarrolladores
CreateAlias

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
Description (p. 457)

A description of the alias.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

FunctionVersion (p. 457)

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
Name (p. 457)

The name of the alias.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 457)

A unique identifier that changes when you update the alias.

Type: String
RoutingConfig (p. 457)

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

458
 AWS Lambda Guía para desarrolladores
CreateAlias

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

459
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

CreateEventSourceMapping
Creates a mapping between an event source and an AWS Lambda function. Lambda reads items from the
event source and triggers the function.

For details about each event source type, see the following topics.

• Using AWS Lambda with Amazon DynamoDB

• Using AWS Lambda with Amazon Kinesis
• Using AWS Lambda with Amazon SQS

The following error handling options are only available for stream sources (DynamoDB and Kinesis):

• BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
• DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
• MaximumRecordAgeInSeconds - Discard records older than the specified age.
• MaximumRetryAttempts - Discard records after the specified number of retries.
• ParallelizationFactor - Process multiple batches from each shard concurrently.

Request Syntax
POST /2015-03-31/event-source-mappings/ HTTP/1.1
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"Enabled": boolean,
"EventSourceArn": "string",
"FunctionName": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"StartingPosition": "string",
"StartingPositionTimestamp": number
}

URI Request Parameters

The request does not use any URI parameters.

Request Body
The request accepts the following data in JSON format.

460
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

BatchSize (p. 460)

The maximum number of items to retrieve in a single batch.

• Amazon Kinesis - Default 100. Max 10,000.
• Amazon DynamoDB Streams - Default 100. Max 1,000.
• Amazon Simple Queue Service - Default 10. Max 10.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

Required: No
BisectBatchOnFunctionError (p. 460)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean

Required: No
DestinationConfig (p. 460)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

Required: No
Enabled (p. 460)

Disables the event source mapping to pause polling and invocation.

Type: Boolean

Required: No
EventSourceArn (p. 460)

The Amazon Resource Name (ARN) of the event source.

• Amazon Kinesis - The ARN of the data stream or a stream consumer.
• Amazon DynamoDB Streams - The ARN of the stream.
• Amazon Simple Queue Service - The ARN of the queue.

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)

Required: Yes
FunctionName (p. 460)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Version or Alias ARN - arn:aws:lambda:us-
west-2:123456789012:function:MyFunction:PROD.
• Partial ARN - 123456789012:function:MyFunction.

461
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

The length constraint applies only to the full ARN. If you specify only the function name, it's limited to
64 characters in length.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: Yes
MaximumBatchingWindowInSeconds (p. 460)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

Required: No
MaximumRecordAgeInSeconds (p. 460)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

Required: No
MaximumRetryAttempts (p. 460)

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

Required: No
ParallelizationFactor (p. 460)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

Required: No
StartingPosition (p. 460)

The position in a stream from which to start reading. Required for Amazon Kinesis and Amazon
DynamoDB Streams sources. AT_TIMESTAMP is only supported for Amazon Kinesis streams.

Type: String

Valid Values: TRIM_HORIZON | LATEST | AT_TIMESTAMP

Required: No
StartingPositionTimestamp (p. 460)

With StartingPosition set to AT_TIMESTAMP, the time from which to start reading, in Unix time
seconds.

462
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

Type: Timestamp

Required: No

Response Syntax
HTTP/1.1 202
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"EventSourceArn": "string",
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"State": "string",
"StateTransitionReason": "string",
"UUID": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 202 response.

The following data is returned in JSON format by the service.

BatchSize (p. 463)

The maximum number of items to retrieve in a single batch.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

BisectBatchOnFunctionError (p. 463)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean
DestinationConfig (p. 463)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

EventSourceArn (p. 463)

The Amazon Resource Name (ARN) of the event source.

463
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
FunctionArn (p. 463)

The ARN of the Lambda function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 463)

The date that the event source mapping was last updated, or its state changed, in Unix time seconds.

Type: Timestamp
LastProcessingResult (p. 463)

The result of the last AWS Lambda invocation of your Lambda function.

Type: String
MaximumBatchingWindowInSeconds (p. 463)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

MaximumRecordAgeInSeconds (p. 463)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

MaximumRetryAttempts (p. 463)

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

ParallelizationFactor (p. 463)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

State (p. 463)

The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.

Type: String
StateTransitionReason (p. 463)

Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.

464
 AWS Lambda Guía para desarrolladores
CreateEventSourceMapping

Type: String
UUID (p. 463)

The identifier of the event source mapping.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

465
 AWS Lambda Guía para desarrolladores
CreateFunction

CreateFunction
Creates a Lambda function. To create a function, you need a deployment package and an execution role.
The deployment package contains your function code. The execution role grants the function permission
to use AWS services, such as Amazon CloudWatch Logs for log streaming and AWS X-Ray for request
tracing.

When you create a function, Lambda provisions an instance of the function and its supporting resources.
If your function connects to a VPC, this process can take a minute or so. During this time, you can't invoke
or modify the function. The State, StateReason, and StateReasonCode fields in the response from
GetFunctionConfiguration (p. 505) indicate when the function is ready to invoke. For more information,
see Function States.

A function has an unpublished version, and can have published versions and aliases. The unpublished
version changes when you update your function's code and configuration. A published version is a
snapshot of your function code and configuration that can't be changed. An alias is a named resource
that maps to a version, and can be changed to map to a different version. Use the Publish parameter to
create version 1 of your function from its initial configuration.

The other parameters let you configure version-specific and function-level settings. You can modify version-
specific settings later with UpdateFunctionConfiguration (p. 605). Function-level settings apply to both the
unpublished and published versions of the function, and include tags (TagResource (p. 584)) and per-
function concurrency limits (PutFunctionConcurrency (p. 570)).

If another account or an AWS service invokes your function, use AddPermission (p. 452) to grant
permission by creating a resource-based IAM policy. You can grant permissions at the function level, on a
version, or on an alias.

To invoke your function directly, use Invoke (p. 527). To invoke your function in response to events in
other AWS services, create an event source mapping (CreateEventSourceMapping (p. 460)), or configure a
function trigger in the other service. For more information, see Invoking Functions.

Request Syntax
POST /2015-03-31/functions HTTP/1.1
Content-type: application/json

{
"Code": {
"S3Bucket": "string",
"S3Key": "string",
"S3ObjectVersion": "string",
"ZipFile": blob
},
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Variables": {
"string" : "string"
}
},
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"Layers": [ "string" ],
"MemorySize": number,
"Publish": boolean,
"Role": "string",

466
 AWS Lambda Guía para desarrolladores
CreateFunction

"Runtime": "string",
"Tags": {
"string" : "string"
},
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ]
}
}

URI Request Parameters

The request does not use any URI parameters.

Request Body
The request accepts the following data in JSON format.

Code (p. 466)

The code for the function.

Type: FunctionCode (p. 633) object

Required: Yes
DeadLetterConfig (p. 466)

A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous
events when they fail processing. For more information, see Dead Letter Queues.

Type: DeadLetterConfig (p. 625) object

Required: No
Description (p. 466)

A description of the function.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
Environment (p. 466)

Environment variables that are accessible from function code during execution.

Type: Environment (p. 627) object

Required: No
FunctionName (p. 466)

The name of the Lambda function.

Name formats
• Function name - my-function.

467
 AWS Lambda Guía para desarrolladores
CreateFunction

• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: Yes
Handler (p. 466)

The name of the method within your code that Lambda calls to execute your function. The format
includes the file name. It can also include namespaces and other qualifiers, depending on the runtime.
For more information, see Programming Model.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+

Required: Yes
KMSKeyArn (p. 466)

The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's
environment variables. If it's not provided, AWS Lambda uses a default service key.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()

Required: No
Layers (p. 466)

A list of function layers to add to the function's execution environment. Specify each layer by its ARN,
including the version.

Type: Array of strings

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+

Required: No
MemorySize (p. 466)

The amount of memory that your function has access to. Increasing the function's memory also
increases its CPU allocation. The default value is 128 MB. The value must be a multiple of 64 MB.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

Required: No

468
 AWS Lambda Guía para desarrolladores
CreateFunction

Publish (p. 466)

Set to true to publish the first version of the function during creation.

Type: Boolean

Required: No
Role (p. 466)

The Amazon Resource Name (ARN) of the function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+

Required: Yes
Runtime (p. 466)

The identifier of the function's runtime.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

Required: Yes
Tags (p. 466)

A list of tags to apply to the function.

Type: String to string map

Required: No
Timeout (p. 466)

The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds.
The maximum allowed value is 900 seconds.

Type: Integer

Valid Range: Minimum value of 1.

Required: No
TracingConfig (p. 466)

Set Mode to Active to sample and trace a subset of incoming requests with AWS X-Ray.

Type: TracingConfig (p. 652) object

Required: No
VpcConfig (p. 466)

For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in
the VPC. When you connect a function to a VPC, it can only access resources and the internet through
that VPC. For more information, see VPC Settings.

Type: VpcConfig (p. 654) object

469
 AWS Lambda Guía para desarrolladores
CreateFunction

Required: No

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

470
 AWS Lambda Guía para desarrolladores
CreateFunction

CodeSha256 (p. 470)

The SHA256 hash of the function's deployment package.

Type: String
CodeSize (p. 470)

The size of the function's deployment package, in bytes.

Type: Long
DeadLetterConfig (p. 470)

The function's dead letter queue.

Type: DeadLetterConfig (p. 625) object

Description (p. 470)

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Environment (p. 470)

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

FunctionArn (p. 470)

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionName (p. 470)

The name of the function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 470)

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+
KMSKeyArn (p. 470)

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

471
 AWS Lambda Guía para desarrolladores
CreateFunction

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
LastModified (p. 470)

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String
LastUpdateStatus (p. 470)

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

Type: String

Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 470)

The reason for the last update that was performed on the function.

Type: String
LastUpdateStatusReasonCode (p. 470)

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
Layers (p. 470)

The function's layers.

Type: Array of Layer (p. 642) objects

MasterArn (p. 470)

For Lambda@Edge functions, the ARN of the master function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
MemorySize (p. 470)

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

RevisionId (p. 470)

The latest updated revision of the function or alias.

Type: String
Role (p. 470)

The function's execution role.

Type: String

472
 AWS Lambda Guía para desarrolladores
CreateFunction

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Runtime (p. 470)

The runtime environment for the Lambda function.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
State (p. 470)

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 470)

The reason for the function's current state.

Type: String
StateReasonCode (p. 470)

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 470)

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

TracingConfig (p. 470)

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Version (p. 470)

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
VpcConfig (p. 470)

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

473
 AWS Lambda Guía para desarrolladores
CreateFunction

Errors
CodeStorageExceededException

You have exceeded your maximum total code size per account. Learn more

HTTP Status Code: 400

InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

474
 AWS Lambda Guía para desarrolladores
DeleteAlias

DeleteAlias
Deletes a Lambda function alias.

Request Syntax
DELETE /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 475)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Name (p. 475)

The name of the alias.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

475
 AWS Lambda Guía para desarrolladores
DeleteAlias

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

476
 AWS Lambda Guía para desarrolladores
DeleteEventSourceMapping

DeleteEventSourceMapping
Deletes an event source mapping. You can get the identifier of a mapping from the output of
ListEventSourceMappings (p. 537).

When you delete an event source mapping, it enters a Deleting state and might not be completely
deleted for several seconds.

Request Syntax
DELETE /2015-03-31/event-source-mappings/UUID HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

UUID (p. 477)

The identifier of the event source mapping.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 202
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"EventSourceArn": "string",
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"State": "string",
"StateTransitionReason": "string",
"UUID": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 202 response.

477
 AWS Lambda Guía para desarrolladores
DeleteEventSourceMapping

The following data is returned in JSON format by the service.

BatchSize (p. 477)

The maximum number of items to retrieve in a single batch.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

BisectBatchOnFunctionError (p. 477)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean
DestinationConfig (p. 477)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

EventSourceArn (p. 477)

The Amazon Resource Name (ARN) of the event source.

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
FunctionArn (p. 477)

The ARN of the Lambda function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 477)

The date that the event source mapping was last updated, or its state changed, in Unix time seconds.

Type: Timestamp
LastProcessingResult (p. 477)

The result of the last AWS Lambda invocation of your Lambda function.

Type: String
MaximumBatchingWindowInSeconds (p. 477)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

MaximumRecordAgeInSeconds (p. 477)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

478
 AWS Lambda Guía para desarrolladores
DeleteEventSourceMapping

MaximumRetryAttempts (p. 477)

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

ParallelizationFactor (p. 477)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

State (p. 477)

The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.

Type: String
StateTransitionReason (p. 477)

Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.

Type: String
UUID (p. 477)

The identifier of the event source mapping.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceInUseException

The operation conflicts with the resource's availability. For example, you attempted to update an
EventSource Mapping in CREATING, or tried to delete a EventSource mapping currently in the
UPDATING state.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

479
 AWS Lambda Guía para desarrolladores
DeleteEventSourceMapping

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

480
 AWS Lambda Guía para desarrolladores
DeleteFunction

DeleteFunction
Deletes a Lambda function. To delete a specific function version, use the Qualifier parameter.
Otherwise, all versions and aliases are deleted.

To delete Lambda event source mappings that invoke a function, use DeleteEventSourceMapping (p. 477).
For AWS services and resources that invoke your function directly, delete the trigger in the service where
you originally configured it.

Request Syntax
DELETE /2015-03-31/functions/FunctionName?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 481)

The name of the Lambda function or version.

Name formats
• Function name - my-function (name-only), my-function:1 (with version).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 481)

Specify a version to delete. You can't delete a version that's referenced by an alias.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

481
 AWS Lambda Guía para desarrolladores
DeleteFunction

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

482
 AWS Lambda Guía para desarrolladores
DeleteFunctionConcurrency

DeleteFunctionConcurrency
Removes a concurrent execution limit from a function.

Request Syntax
DELETE /2017-10-31/functions/FunctionName/concurrency HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 483)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

483
 AWS Lambda Guía para desarrolladores
DeleteFunctionConcurrency

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

484
 AWS Lambda Guía para desarrolladores
DeleteFunctionEventInvokeConfig

DeleteFunctionEventInvokeConfig
Deletes the configuration for asynchronous invocation for a function, version, or alias.

To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig (p. 573).

Request Syntax
DELETE /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 485)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 485)

A version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

485
 AWS Lambda Guía para desarrolladores
DeleteFunctionEventInvokeConfig

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

486
 AWS Lambda Guía para desarrolladores
DeleteLayerVersion

DeleteLayerVersion
Deletes a version of an AWS Lambda layer. Deleted versions can no longer be viewed or added to
functions. To avoid breaking functions, a copy of the version remains in Lambda until no functions refer to it.

Request Syntax
DELETE /2018-10-31/layers/LayerName/versions/VersionNumber HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 487)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
VersionNumber (p. 487)

The version number.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

487
 AWS Lambda Guía para desarrolladores
DeleteLayerVersion

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

488
 AWS Lambda Guía para desarrolladores
DeleteProvisionedConcurrencyConfig

DeleteProvisionedConcurrencyConfig
Deletes the provisioned concurrency configuration for a function.

Request Syntax
DELETE /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier
HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 489)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 489)

The version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

489
 AWS Lambda Guía para desarrolladores
DeleteProvisionedConcurrencyConfig

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

490
 AWS Lambda Guía para desarrolladores
GetAccountSettings

GetAccountSettings
Retrieves details about your account's limits and usage in an AWS Region.

Request Syntax
GET /2016-08-19/account-settings/ HTTP/1.1

URI Request Parameters

The request does not use any URI parameters.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"AccountLimit": {
"CodeSizeUnzipped": number,
"CodeSizeZipped": number,
"ConcurrentExecutions": number,
"TotalCodeSize": number,
"UnreservedConcurrentExecutions": number
},
"AccountUsage": {
"FunctionCount": number,
"TotalCodeSize": number
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

AccountLimit (p. 491)

Limits that are related to concurrency and code storage.

Type: AccountLimit (p. 619) object

AccountUsage (p. 491)

The number of functions and amount of storage in use.

Type: AccountUsage (p. 620) object

Errors
ServiceException

The AWS Lambda service encountered an internal error.

491
 AWS Lambda Guía para desarrolladores
GetAccountSettings

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

492
 AWS Lambda Guía para desarrolladores
GetAlias

GetAlias
Returns details about a Lambda function alias.

Request Syntax
GET /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 493)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Name (p. 493)

The name of the alias.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"AliasArn": "string",
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RevisionId": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}

493
 AWS Lambda Guía para desarrolladores
GetAlias

}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

AliasArn (p. 493)

The Amazon Resource Name (ARN) of the alias.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
Description (p. 493)

A description of the alias.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

FunctionVersion (p. 493)

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
Name (p. 493)

The name of the alias.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 493)

A unique identifier that changes when you update the alias.

Type: String
RoutingConfig (p. 493)

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

494
 AWS Lambda Guía para desarrolladores
GetAlias

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

495
 AWS Lambda Guía para desarrolladores
GetEventSourceMapping

GetEventSourceMapping
Returns details about an event source mapping. You can get the identifier of a mapping from the output of
ListEventSourceMappings (p. 537).

Request Syntax
GET /2015-03-31/event-source-mappings/UUID HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

UUID (p. 496)

The identifier of the event source mapping.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"EventSourceArn": "string",
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"State": "string",
"StateTransitionReason": "string",
"UUID": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

496
 AWS Lambda Guía para desarrolladores
GetEventSourceMapping

BatchSize (p. 496)

The maximum number of items to retrieve in a single batch.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

BisectBatchOnFunctionError (p. 496)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean
DestinationConfig (p. 496)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

EventSourceArn (p. 496)

The Amazon Resource Name (ARN) of the event source.

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
FunctionArn (p. 496)

The ARN of the Lambda function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 496)

The date that the event source mapping was last updated, or its state changed, in Unix time seconds.

Type: Timestamp
LastProcessingResult (p. 496)

The result of the last AWS Lambda invocation of your Lambda function.

Type: String
MaximumBatchingWindowInSeconds (p. 496)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

MaximumRecordAgeInSeconds (p. 496)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

MaximumRetryAttempts (p. 496)

(Streams) The maximum number of times to retry when the function returns an error.

497
 AWS Lambda Guía para desarrolladores
GetEventSourceMapping

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

ParallelizationFactor (p. 496)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

State (p. 496)

The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.

Type: String
StateTransitionReason (p. 496)

Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.

Type: String
UUID (p. 496)

The identifier of the event source mapping.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

498
 AWS Lambda Guía para desarrolladores
GetEventSourceMapping

• AWS SDK for .NET

• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

499
 AWS Lambda Guía para desarrolladores
GetFunction

GetFunction
Returns information about the function or function version, with a link to download the deployment package
that's valid for 10 minutes. If you specify a function version, only details that are specific to that version are
returned.

Request Syntax
GET /2015-03-31/functions/FunctionName?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 500)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 500)

Specify a version or alias to get details about a published version of the function.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Code": {
"Location": "string",
"RepositoryType": "string"
},
"Concurrency": {
"ReservedConcurrentExecutions": number

500
 AWS Lambda Guía para desarrolladores
GetFunction

},
"Configuration": {
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
},
"Tags": {
"string" : "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Code (p. 500)

The deployment package of the function or version.

501
 AWS Lambda Guía para desarrolladores
GetFunction

Type: FunctionCodeLocation (p. 634) object

Concurrency (p. 500)

The function's reserved concurrency.

Type: Concurrency (p. 624) object

Configuration (p. 500)

The configuration of the function or version.

Type: FunctionConfiguration (p. 635) object

Tags (p. 500)

The function's tags.

Type: String to string map

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

502
 AWS Lambda Guía para desarrolladores
GetFunctionConcurrency

GetFunctionConcurrency
Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a
function, use PutFunctionConcurrency (p. 570).

Request Syntax
GET /2019-09-30/functions/FunctionName/concurrency HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 503)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"ReservedConcurrentExecutions": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

ReservedConcurrentExecutions (p. 503)

The number of simultaneous executions that are reserved for the function.

Type: Integer

503
 AWS Lambda Guía para desarrolladores
GetFunctionConcurrency

Valid Range: Minimum value of 0.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

504
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

GetFunctionConfiguration
Returns the version-specific settings of a Lambda function or version. The output includes
only options that can vary between versions of a function. To modify these settings, use
UpdateFunctionConfiguration (p. 605).

To get all of a function's details, including function-level settings, use GetFunction (p. 500).

Request Syntax
GET /2015-03-31/functions/FunctionName/configuration?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 505)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 505)

Specify a version or alias to get details about a published version of the function.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},

505
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

CodeSha256 (p. 505)

The SHA256 hash of the function's deployment package.

Type: String
CodeSize (p. 505)

The size of the function's deployment package, in bytes.

Type: Long
DeadLetterConfig (p. 505)

The function's dead letter queue.

506
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

Type: DeadLetterConfig (p. 625) object

Description (p. 505)

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Environment (p. 505)

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

FunctionArn (p. 505)

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionName (p. 505)

The name of the function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 505)

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+
KMSKeyArn (p. 505)

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
LastModified (p. 505)

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String
LastUpdateStatus (p. 505)

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

507
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

Type: String

Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 505)

The reason for the last update that was performed on the function.

Type: String
LastUpdateStatusReasonCode (p. 505)

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
Layers (p. 505)

The function's layers.

Type: Array of Layer (p. 642) objects

MasterArn (p. 505)

For Lambda@Edge functions, the ARN of the master function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
MemorySize (p. 505)

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

RevisionId (p. 505)

The latest updated revision of the function or alias.

Type: String
Role (p. 505)

The function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Runtime (p. 505)

The runtime environment for the Lambda function.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

508
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

State (p. 505)

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 505)

The reason for the function's current state.

Type: String
StateReasonCode (p. 505)

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 505)

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

TracingConfig (p. 505)

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Version (p. 505)

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
VpcConfig (p. 505)

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

509
 AWS Lambda Guía para desarrolladores
GetFunctionConfiguration

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

510
 AWS Lambda Guía para desarrolladores
GetFunctionEventInvokeConfig

GetFunctionEventInvokeConfig
Retrieves the configuration for asynchronous invocation for a function, version, or alias.

To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig (p. 573).

Request Syntax
GET /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 511)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 511)

A version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}

511
 AWS Lambda Guía para desarrolladores
GetFunctionEventInvokeConfig

},
"FunctionArn": "string",
"LastModified": number,
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

DestinationConfig (p. 511)

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

FunctionArn (p. 511)

The Amazon Resource Name (ARN) of the function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 511)

The date and time that the configuration was last updated, in Unix time seconds.

Type: Timestamp
MaximumEventAgeInSeconds (p. 511)

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

MaximumRetryAttempts (p. 511)

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

512
 AWS Lambda Guía para desarrolladores
GetFunctionEventInvokeConfig

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

513
 AWS Lambda Guía para desarrolladores
GetLayerVersion

GetLayerVersion
Returns information about a version of an AWS Lambda layer, with a link to download the layer archive
that's valid for 10 minutes.

Request Syntax
GET /2018-10-31/layers/LayerName/versions/VersionNumber HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 514)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
VersionNumber (p. 514)

The version number.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"CompatibleRuntimes": [ "string" ],
"Content": {
"CodeSha256": "string",
"CodeSize": number,
"Location": "string"
},
"CreatedDate": "string",
"Description": "string",
"LayerArn": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

514
 AWS Lambda Guía para desarrolladores
GetLayerVersion

CompatibleRuntimes (p. 514)

The layer's compatible runtimes.

Type: Array of strings

Array Members: Maximum number of 5 items.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
Content (p. 514)

Details about the layer version.

Type: LayerVersionContentOutput (p. 645) object

CreatedDate (p. 514)

The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:[Link]).

Type: String
Description (p. 514)

The description of the version.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

LayerArn (p. 514)

The ARN of the layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+
LayerVersionArn (p. 514)

The ARN of the layer version.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+
LicenseInfo (p. 514)

The layer's software license.

Type: String

Length Constraints: Maximum length of 512.

Version (p. 514)

The version number.

Type: Long

515
 AWS Lambda Guía para desarrolladores
GetLayerVersion

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

516
 AWS Lambda Guía para desarrolladores
GetLayerVersionByArn

GetLayerVersionByArn
Returns information about a version of an AWS Lambda layer, with a link to download the layer archive
that's valid for 10 minutes.

Request Syntax
GET /2018-10-31/layers?find=LayerVersion&Arn=Arn HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

Arn (p. 517)

The ARN of the layer version.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"CompatibleRuntimes": [ "string" ],
"Content": {
"CodeSha256": "string",
"CodeSize": number,
"Location": "string"
},
"CreatedDate": "string",
"Description": "string",
"LayerArn": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

CompatibleRuntimes (p. 517)

The layer's compatible runtimes.

Type: Array of strings

517
 AWS Lambda Guía para desarrolladores
GetLayerVersionByArn

Array Members: Maximum number of 5 items.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
Content (p. 517)

Details about the layer version.

Type: LayerVersionContentOutput (p. 645) object

CreatedDate (p. 517)

The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:[Link]).

Type: String
Description (p. 517)

The description of the version.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

LayerArn (p. 517)

The ARN of the layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+
LayerVersionArn (p. 517)

The ARN of the layer version.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+
LicenseInfo (p. 517)

The layer's software license.

Type: String

Length Constraints: Maximum length of 512.

Version (p. 517)

The version number.

Type: Long

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

518
 AWS Lambda Guía para desarrolladores
GetLayerVersionByArn

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

519
 AWS Lambda Guía para desarrolladores
GetLayerVersionPolicy

GetLayerVersionPolicy
Returns the permission policy for a version of an AWS Lambda layer. For more information, see
AddLayerVersionPermission (p. 449).

Request Syntax
GET /2018-10-31/layers/LayerName/versions/VersionNumber/policy HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 520)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
VersionNumber (p. 520)

The version number.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Policy": "string",
"RevisionId": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Policy (p. 520)

The policy document.

Type: String
RevisionId (p. 520)

A unique identifier for the current revision of the policy.

Type: String

520
 AWS Lambda Guía para desarrolladores
GetLayerVersionPolicy

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

521
 AWS Lambda Guía para desarrolladores
GetPolicy

GetPolicy
Returns the resource-based IAM policy for a function, version, or alias.

Request Syntax
GET /2015-03-31/functions/FunctionName/policy?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 522)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 522)

Specify a version or alias to get the policy for that resource.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Policy": "string",
"RevisionId": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

522
 AWS Lambda Guía para desarrolladores
GetPolicy

The following data is returned in JSON format by the service.

Policy (p. 522)

The resource-based policy.

Type: String
RevisionId (p. 522)

A unique identifier for the current revision of the policy.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

523
 AWS Lambda Guía para desarrolladores
GetProvisionedConcurrencyConfig

GetProvisionedConcurrencyConfig
Retrieves the provisioned concurrency configuration for a function's alias or version.

Request Syntax
GET /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 524)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 524)

The version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"AllocatedProvisionedConcurrentExecutions": number,
"AvailableProvisionedConcurrentExecutions": number,
"LastModified": "string",
"RequestedProvisionedConcurrentExecutions": number,
"Status": "string",
"StatusReason": "string"
}

524
 AWS Lambda Guía para desarrolladores
GetProvisionedConcurrencyConfig

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

AllocatedProvisionedConcurrentExecutions (p. 524)

The amount of provisioned concurrency allocated.

Type: Integer

Valid Range: Minimum value of 0.

AvailableProvisionedConcurrentExecutions (p. 524)

The amount of provisioned concurrency available.

Type: Integer

Valid Range: Minimum value of 0.

LastModified (p. 524)

The date and time that a user last updated the configuration, in ISO 8601 format.

Type: String
RequestedProvisionedConcurrentExecutions (p. 524)

The amount of provisioned concurrency requested.

Type: Integer

Valid Range: Minimum value of 1.

Status (p. 524)

The status of the allocation process.

Type: String

Valid Values: IN_PROGRESS | READY | FAILED

StatusReason (p. 524)

For failed allocations, the reason that provisioned concurrency could not be allocated.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ProvisionedConcurrencyConfigNotFoundException

The specified configuration does not exist.

HTTP Status Code: 404

525
 AWS Lambda Guía para desarrolladores
GetProvisionedConcurrencyConfig

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

526
 AWS Lambda Guía para desarrolladores
Invoke

Invoke
Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
asynchronously. To invoke a function asynchronously, set InvocationType to Event.

For synchronous invocation, details about the function response, including errors, are included in the
response body and headers. For either invocation type, you can find more information in the execution log
and trace.

When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type,
client, event source, and invocation type. For example, if you invoke a function asynchronously and it
returns an error, Lambda executes the function up to two more times. For more information, see Retry
Behavior.

For asynchronous invocation, Lambda adds events to a queue before sending them to your function. If your
function does not have enough capacity to keep up with the queue, events may be lost. Occasionally, your
function may receive the same event multiple times, even if no error occurs. To retain events that were not
processed, configure your function with a dead-letter queue.

The status code in the API response doesn't reflect function errors. Error codes are reserved
for errors that prevent your function from executing, such as permissions errors, limit
errors, or issues with your function's code and configuration. For example, Lambda returns
TooManyRequestsException if executing the function would cause you to exceed a concurrency
limit at either the account level (ConcurrentInvocationLimitExceeded) or function level
(ReservedFunctionConcurrentInvocationLimitExceeded).

For functions with a long timeout, your client might be disconnected during synchronous invocation while it
waits for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long
connections with timeout or keep-alive settings.

This operation requires permission for the lambda:InvokeFunction action.

Request Syntax
POST /2015-03-31/functions/FunctionName/invocations?Qualifier=Qualifier HTTP/1.1
X-Amz-Invocation-Type: InvocationType
X-Amz-Log-Type: LogType
X-Amz-Client-Context: ClientContext

Payload

URI Request Parameters

The request requires the following URI parameters.

ClientContext (p. 527)

Up to 3583 bytes of base64-encoded data about the invoking client to pass to the function in the
context object.
FunctionName (p. 527)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

527
 AWS Lambda Guía para desarrolladores
Invoke

• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
InvocationType (p. 527)

Choose from the following options.

• RequestResponse (default) - Invoke the function synchronously. Keep the connection open until
the function returns a response or times out. The API response includes the function response and
additional data.
• Event - Invoke the function asynchronously. Send events that fail multiple times to the function's
dead-letter queue (if it's configured). The API response only includes a status code.
• DryRun - Validate parameter values and verify that the user or role has permission to invoke the
function.

Valid Values: Event | RequestResponse | DryRun

LogType (p. 527)

Set to Tail to include the execution log in the response.

Valid Values: None | Tail

Qualifier (p. 527)

Specify a version or alias to invoke a published version of the function.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request accepts the following binary data.

Payload (p. 527)

The JSON that you want to provide to your Lambda function as input.

Response Syntax
HTTP/1.1 StatusCode
X-Amz-Function-Error: FunctionError
X-Amz-Log-Result: LogResult
X-Amz-Executed-Version: ExecutedVersion

Payload

Response Elements
If the action is successful, the service sends back the following HTTP response.

528
 AWS Lambda Guía para desarrolladores
Invoke

StatusCode (p. 528)

The HTTP status code is in the 200 range for a successful request. For the RequestResponse
invocation type, this status code is 200. For the Event invocation type, this status code is 202. For the
DryRun invocation type, the status code is 204.

The response returns the following HTTP headers.

ExecutedVersion (p. 528)

The version of the function that executed. When you invoke a function with an alias, this indicates
which version the alias resolved to.

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
FunctionError (p. 528)

If present, indicates that an error occurred during function execution. Details about the error are
included in the response payload.
LogResult (p. 528)

The last 4 KB of the execution log, which is base64 encoded.

The response returns the following as the HTTP body.

Payload (p. 528)

The response from the function, or an error object.

Errors
EC2AccessDeniedException

Need additional permissions to configure VPC settings.

HTTP Status Code: 502

EC2ThrottledException

AWS Lambda was throttled by Amazon EC2 during Lambda function initialization using the execution
role provided for the Lambda function.

HTTP Status Code: 502

EC2UnexpectedException

AWS Lambda received an unexpected EC2 client exception while setting up for the Lambda function.

HTTP Status Code: 502

ENILimitReachedException

AWS Lambda was not able to create an elastic network interface in the VPC, specified as part of
Lambda function configuration, because the limit for network interfaces has been reached.

HTTP Status Code: 502

InvalidParameterValueException

One of the parameters in the request is invalid.

529
 AWS Lambda Guía para desarrolladores
Invoke

HTTP Status Code: 400

InvalidRequestContentException

The request body could not be parsed as JSON.

HTTP Status Code: 400

InvalidRuntimeException

The runtime or runtime version specified is not supported.

HTTP Status Code: 502

InvalidSecurityGroupIDException

The Security Group ID provided in the Lambda function VPC configuration is invalid.

HTTP Status Code: 502

InvalidSubnetIDException

The Subnet ID provided in the Lambda function VPC configuration is invalid.

HTTP Status Code: 502

InvalidZipFileException

AWS Lambda could not unzip the deployment package.

HTTP Status Code: 502

KMSAccessDeniedException

Lambda was unable to decrypt the environment variables because KMS access was denied. Check the
Lambda function's KMS permissions.

HTTP Status Code: 502

KMSDisabledException

Lambda was unable to decrypt the environment variables because the KMS key used is disabled.
Check the Lambda function's KMS key settings.

HTTP Status Code: 502

KMSInvalidStateException

Lambda was unable to decrypt the environment variables because the KMS key used is in an invalid
state for Decrypt. Check the function's KMS key settings.

HTTP Status Code: 502

KMSNotFoundException

Lambda was unable to decrypt the environment variables because the KMS key was not found. Check
the function's KMS key settings.

HTTP Status Code: 502

RequestTooLargeException

The request payload exceeded the Invoke request body JSON input limit. For more information, see
Limits.

HTTP Status Code: 413

ResourceConflictException

The resource already exists, or another operation is in progress.

530
 AWS Lambda Guía para desarrolladores
Invoke

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ResourceNotReadyException

The function is inactive and its VPC connection is no longer available. Wait for the VPC connection to
reestablish and try again.

HTTP Status Code: 502

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

SubnetIPAddressLimitReachedException

AWS Lambda was not able to set up VPC access for the Lambda function because one or more
configured subnets has no available IP addresses.

HTTP Status Code: 502

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

UnsupportedMediaTypeException

The content type of the Invoke request body is not JSON.

HTTP Status Code: 415

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

531
 AWS Lambda Guía para desarrolladores
InvokeAsync

InvokeAsync
This action has been deprecated.
Important

For asynchronous function invocation, use Invoke (p. 527).

Invokes a function asynchronously.

Request Syntax
POST /2014-11-13/functions/FunctionName/invoke-async/ HTTP/1.1

InvokeArgs

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 532)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following binary data.

InvokeArgs (p. 532)

The JSON that you want to provide to your Lambda function as input.

Response Syntax
HTTP/1.1 Status

Response Elements
If the action is successful, the service sends back the following HTTP response.

532
 AWS Lambda Guía para desarrolladores
InvokeAsync

Status (p. 532)

The status code.

Errors
InvalidRequestContentException

The request body could not be parsed as JSON.

HTTP Status Code: 400

InvalidRuntimeException

The runtime or runtime version specified is not supported.

HTTP Status Code: 502

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

533
 AWS Lambda Guía para desarrolladores
ListAliases

ListAliases
Returns a list of aliases for a Lambda function.

Request Syntax
GET /2015-03-31/functions/FunctionName/aliases?
FunctionVersion=FunctionVersion&Marker=Marker&MaxItems=MaxItems HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 534)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionVersion (p. 534)

Specify a function version to only list aliases that invoke that version.

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
Marker (p. 534)

Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MaxItems (p. 534)

Limit the number of aliases returned.

Valid Range: Minimum value of 1. Maximum value of 10000.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

534
 AWS Lambda Guía para desarrolladores
ListAliases

{
"Aliases": [
{
"AliasArn": "string",
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RevisionId": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}
],
"NextMarker": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Aliases (p. 534)

A list of aliases.

Type: Array of AliasConfiguration (p. 621) objects

NextMarker (p. 534)

The pagination token that's included if more results are available.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

535
 AWS Lambda Guía para desarrolladores
ListAliases

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

536
 AWS Lambda Guía para desarrolladores
ListEventSourceMappings

ListEventSourceMappings
Lists event source mappings. Specify an EventSourceArn to only show event source mappings for a
single event source.

Request Syntax
GET /2015-03-31/event-source-mappings/?
EventSourceArn=EventSourceArn&FunctionName=FunctionName&Marker=Marker&MaxItems=MaxItems
HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

EventSourceArn (p. 537)

The Amazon Resource Name (ARN) of the event source.

• Amazon Kinesis - The ARN of the data stream or a stream consumer.
• Amazon DynamoDB Streams - The ARN of the stream.
• Amazon Simple Queue Service - The ARN of the queue.

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
FunctionName (p. 537)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Version or Alias ARN - arn:aws:lambda:us-
west-2:123456789012:function:MyFunction:PROD.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it's limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Marker (p. 537)

A pagination token returned by a previous call.

MaxItems (p. 537)

The maximum number of event source mappings to return.

Valid Range: Minimum value of 1. Maximum value of 10000.

Request Body
The request does not have a request body.

537
 AWS Lambda Guía para desarrolladores
ListEventSourceMappings

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"EventSourceMappings": [
{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"EventSourceArn": "string",
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"State": "string",
"StateTransitionReason": "string",
"UUID": "string"
}
],
"NextMarker": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

EventSourceMappings (p. 538)

A list of event source mappings.

Type: Array of EventSourceMappingConfiguration (p. 630) objects

NextMarker (p. 538)

A pagination token that's returned when the response doesn't contain all event source mappings.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

538
 AWS Lambda Guía para desarrolladores
ListEventSourceMappings

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

539
 AWS Lambda Guía para desarrolladores
ListFunctionEventInvokeConfigs

ListFunctionEventInvokeConfigs
Retrieves a list of configurations for asynchronous invocation for a function.

To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig (p. 573).

Request Syntax
GET /2019-09-25/functions/FunctionName/event-invoke-config/list?
Marker=Marker&MaxItems=MaxItems HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 540)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Marker (p. 540)

Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MaxItems (p. 540)

The maximum number of configurations to return.

Valid Range: Minimum value of 1. Maximum value of 50.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"FunctionEventInvokeConfigs": [
{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"

540
 AWS Lambda Guía para desarrolladores
ListFunctionEventInvokeConfigs

},
"OnSuccess": {
"Destination": "string"
}
},
"FunctionArn": "string",
"LastModified": number,
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}
],
"NextMarker": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

FunctionEventInvokeConfigs (p. 540)

A list of configurations.

Type: Array of FunctionEventInvokeConfig (p. 640) objects

NextMarker (p. 540)

The pagination token that's included if more results are available.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

541
 AWS Lambda Guía para desarrolladores
ListFunctionEventInvokeConfigs

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

542
 AWS Lambda Guía para desarrolladores
ListFunctions

ListFunctions
Returns a list of Lambda functions, with the version-specific configuration of each. Lambda returns up to 50
functions per call.

Set FunctionVersion to ALL to include all published versions of each function in addition to the
unpublished version. To get more information about a function or version, use GetFunction (p. 500).

Request Syntax
GET /2015-03-31/functions/?
FunctionVersion=FunctionVersion&Marker=Marker&MasterRegion=MasterRegion&MaxItems=MaxItems
HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionVersion (p. 543)

Set to ALL to include entries for all published versions of each function.

Valid Values: ALL

Marker (p. 543)

Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MasterRegion (p. 543)

For Lambda@Edge functions, the AWS Region of the master function. For example, us-east-1 filters
the list of functions to only include Lambda@Edge functions replicated from a master function in US
East (N. Virginia). If specified, you must set FunctionVersion to ALL.

Pattern: ALL|[a-z]{2}(-gov)?-[a-z]+-\d{1}
MaxItems (p. 543)

The maximum number of functions to return.

Valid Range: Minimum value of 1. Maximum value of 10000.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Functions": [
{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},

543
 AWS Lambda Guía para desarrolladores
ListFunctions

"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}
],
"NextMarker": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Functions (p. 543)

A list of Lambda functions.

Type: Array of FunctionConfiguration (p. 635) objects

NextMarker (p. 543)

The pagination token that's included if more results are available.

Type: String

544
 AWS Lambda Guía para desarrolladores
ListFunctions

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

545
 AWS Lambda Guía para desarrolladores
ListLayers

ListLayers
Lists AWS Lambda layers and shows information about the latest version of each. Specify a runtime
identifier to list only layers that indicate that they're compatible with that runtime.

Request Syntax
GET /2018-10-31/layers?CompatibleRuntime=CompatibleRuntime&Marker=Marker&MaxItems=MaxItems
HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

CompatibleRuntime (p. 546)

A runtime identifier. For example, go1.x.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
Marker (p. 546)

A pagination token returned by a previous call.

MaxItems (p. 546)

The maximum number of layers to return.

Valid Range: Minimum value of 1. Maximum value of 50.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Layers": [
{
"LatestMatchingVersion": {
"CompatibleRuntimes": [ "string" ],
"CreatedDate": "string",
"Description": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number
},
"LayerArn": "string",
"LayerName": "string"
}
],
"NextMarker": "string"
}

546
 AWS Lambda Guía para desarrolladores
ListLayers

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Layers (p. 546)

A list of function layers.

Type: Array of LayersListItem (p. 643) objects

NextMarker (p. 546)

A pagination token returned when the response doesn't contain all layers.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

547
 AWS Lambda Guía para desarrolladores
ListLayerVersions

ListLayerVersions
Lists the versions of an AWS Lambda layer. Versions that have been deleted aren't listed. Specify a
runtime identifier to list only versions that indicate that they're compatible with that runtime.

Request Syntax
GET /2018-10-31/layers/LayerName/versions?
CompatibleRuntime=CompatibleRuntime&Marker=Marker&MaxItems=MaxItems HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

CompatibleRuntime (p. 548)

A runtime identifier. For example, go1.x.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
LayerName (p. 548)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
Marker (p. 548)

A pagination token returned by a previous call.

MaxItems (p. 548)

The maximum number of versions to return.

Valid Range: Minimum value of 1. Maximum value of 50.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"LayerVersions": [
{
"CompatibleRuntimes": [ "string" ],
"CreatedDate": "string",
"Description": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number

548
 AWS Lambda Guía para desarrolladores
ListLayerVersions

}
],
"NextMarker": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

LayerVersions (p. 548)

A list of versions.

Type: Array of LayerVersionsListItem (p. 646) objects

NextMarker (p. 548)

A pagination token returned when the response doesn't contain all versions.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript

549
 AWS Lambda Guía para desarrolladores
ListLayerVersions

• AWS SDK for PHP V3

• AWS SDK for Python
• AWS SDK for Ruby V3

550
 AWS Lambda Guía para desarrolladores
ListProvisionedConcurrencyConfigs

ListProvisionedConcurrencyConfigs
Retrieves a list of provisioned concurrency configurations for a function.

Request Syntax
GET /2019-09-30/functions/FunctionName/provisioned-concurrency?
List=ALL&Marker=Marker&MaxItems=MaxItems HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 551)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Marker (p. 551)

Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MaxItems (p. 551)

Specify a number to limit the number of configurations returned.

Valid Range: Minimum value of 1. Maximum value of 50.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"NextMarker": "string",
"ProvisionedConcurrencyConfigs": [
{
"AllocatedProvisionedConcurrentExecutions": number,
"AvailableProvisionedConcurrentExecutions": number,
"FunctionArn": "string",

551
 AWS Lambda Guía para desarrolladores
ListProvisionedConcurrencyConfigs

"LastModified": "string",
"RequestedProvisionedConcurrentExecutions": number,
"Status": "string",
"StatusReason": "string"
}
]
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

NextMarker (p. 551)

The pagination token that's included if more results are available.

Type: String
ProvisionedConcurrencyConfigs (p. 551)

A list of provisioned concurrency configurations.

Type: Array of ProvisionedConcurrencyConfigListItem (p. 650) objects

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go

552
 AWS Lambda Guía para desarrolladores
ListProvisionedConcurrencyConfigs

• AWS SDK for Java

• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

553
 AWS Lambda Guía para desarrolladores
ListTags

ListTags
Returns a function's tags. You can also view tags with GetFunction (p. 500).

Request Syntax
GET /2017-03-31/tags/ARN HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

ARN (p. 554)

The function's Amazon Resource Name (ARN).

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"Tags": {
"string" : "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

Tags (p. 554)

The function's tags.

Type: String to string map

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

554
 AWS Lambda Guía para desarrolladores
ListTags

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

555
 AWS Lambda Guía para desarrolladores
ListVersionsByFunction

ListVersionsByFunction
Returns a list of versions, with the version-specific configuration of each. Lambda returns up to 50 versions
per call.

Request Syntax
GET /2015-03-31/functions/FunctionName/versions?Marker=Marker&MaxItems=MaxItems HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 556)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Marker (p. 556)

Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MaxItems (p. 556)

The maximum number of versions to return.

Valid Range: Minimum value of 1. Maximum value of 10000.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"NextMarker": "string",
"Versions": [
{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"

556
 AWS Lambda Guía para desarrolladores
ListVersionsByFunction

},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}
]
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

NextMarker (p. 556)

The pagination token that's included if more results are available.

Type: String
Versions (p. 556)

A list of Lambda function versions.

Type: Array of FunctionConfiguration (p. 635) objects

557
 AWS Lambda Guía para desarrolladores
ListVersionsByFunction

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

558
 AWS Lambda Guía para desarrolladores
PublishLayerVersion

PublishLayerVersion
Creates an AWS Lambda layer from a ZIP archive. Each time you call PublishLayerVersion with the
same layer name, a new version is created.

Add layers to your function with CreateFunction (p. 466) or UpdateFunctionConfiguration (p. 605).

Request Syntax
POST /2018-10-31/layers/LayerName/versions HTTP/1.1
Content-type: application/json

{
"CompatibleRuntimes": [ "string" ],
"Content": {
"S3Bucket": "string",
"S3Key": "string",
"S3ObjectVersion": "string",
"ZipFile": blob
},
"Description": "string",
"LicenseInfo": "string"
}

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 559)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+

Request Body
The request accepts the following data in JSON format.

CompatibleRuntimes (p. 559)

A list of compatible function runtimes. Used for filtering with ListLayers (p. 546) and
ListLayerVersions (p. 548).

Type: Array of strings

Array Members: Maximum number of 5 items.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

Required: No
Content (p. 559)

The function layer archive.

559
 AWS Lambda Guía para desarrolladores
PublishLayerVersion

Type: LayerVersionContentInput (p. 644) object

Required: Yes
Description (p. 559)

The description of the version.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
LicenseInfo (p. 559)

The layer's software license. It can be any of the following:

• An SPDX license identifier. For example, MIT.
• The URL of a license hosted on the internet. For example, [Link]
licenses/MIT.
• The full text of the license.

Type: String

Length Constraints: Maximum length of 512.

Required: No

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"CompatibleRuntimes": [ "string" ],
"Content": {
"CodeSha256": "string",
"CodeSize": number,
"Location": "string"
},
"CreatedDate": "string",
"Description": "string",
"LayerArn": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

CompatibleRuntimes (p. 560)

The layer's compatible runtimes.

Type: Array of strings

Array Members: Maximum number of 5 items.

560
 AWS Lambda Guía para desarrolladores
PublishLayerVersion

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
Content (p. 560)

Details about the layer version.

Type: LayerVersionContentOutput (p. 645) object

CreatedDate (p. 560)

The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:[Link]).

Type: String
Description (p. 560)

The description of the version.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

LayerArn (p. 560)

The ARN of the layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+
LayerVersionArn (p. 560)

The ARN of the layer version.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+
LicenseInfo (p. 560)

The layer's software license.

Type: String

Length Constraints: Maximum length of 512.

Version (p. 560)

The version number.

Type: Long

Errors
CodeStorageExceededException

You have exceeded your maximum total code size per account. Learn more

561
 AWS Lambda Guía para desarrolladores
PublishLayerVersion

HTTP Status Code: 400

InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

562
 AWS Lambda Guía para desarrolladores
PublishVersion

PublishVersion
Creates a version from the current code and configuration of a function. Use versions to create a snapshot
of your function code and configuration that doesn't change.

AWS Lambda doesn't publish a version if the function's configuration and code haven't changed since the
last version. Use UpdateFunctionCode (p. 598) or UpdateFunctionConfiguration (p. 605) to update the
function before publishing a version.

Clients can invoke versions directly or with an alias. To create an alias, use CreateAlias (p. 456).

Request Syntax
POST /2015-03-31/functions/FunctionName/versions HTTP/1.1
Content-type: application/json

{
"CodeSha256": "string",
"Description": "string",
"RevisionId": "string"
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 563)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

CodeSha256 (p. 563)

Only publish a version if the hash value matches the value that's specified. Use this option to avoid
publishing a version if the function code has changed since you last updated it. You can get the hash
for the version that you uploaded from the output of UpdateFunctionCode (p. 598).

Type: String

Required: No

563
 AWS Lambda Guía para desarrolladores
PublishVersion

Description (p. 563)

A description for the version to override the description in the function configuration.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
RevisionId (p. 563)

Only update the function if the revision ID matches the ID that's specified. Use this option to avoid
publishing a version if the function configuration has changed since you last updated it.

Type: String

Required: No

Response Syntax
HTTP/1.1 201
Content-type: application/json

{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,

564
 AWS Lambda Guía para desarrolladores
PublishVersion

"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 201 response.

The following data is returned in JSON format by the service.

CodeSha256 (p. 564)

The SHA256 hash of the function's deployment package.

Type: String
CodeSize (p. 564)

The size of the function's deployment package, in bytes.

Type: Long
DeadLetterConfig (p. 564)

The function's dead letter queue.

Type: DeadLetterConfig (p. 625) object

Description (p. 564)

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Environment (p. 564)

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

FunctionArn (p. 564)

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionName (p. 564)

The name of the function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 170.

565
 AWS Lambda Guía para desarrolladores
PublishVersion

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 564)

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+
KMSKeyArn (p. 564)

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
LastModified (p. 564)

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String
LastUpdateStatus (p. 564)

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

Type: String

Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 564)

The reason for the last update that was performed on the function.

Type: String
LastUpdateStatusReasonCode (p. 564)

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
Layers (p. 564)

The function's layers.

Type: Array of Layer (p. 642) objects

MasterArn (p. 564)

For Lambda@Edge functions, the ARN of the master function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

566
 AWS Lambda Guía para desarrolladores
PublishVersion

MemorySize (p. 564)

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

RevisionId (p. 564)

The latest updated revision of the function or alias.

Type: String
Role (p. 564)

The function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Runtime (p. 564)

The runtime environment for the Lambda function.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
State (p. 564)

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 564)

The reason for the function's current state.

Type: String
StateReasonCode (p. 564)

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 564)

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

567
 AWS Lambda Guía para desarrolladores
PublishVersion

TracingConfig (p. 564)

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Version (p. 564)

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
VpcConfig (p. 564)

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

Errors
CodeStorageExceededException

You have exceeded your maximum total code size per account. Learn more

HTTP Status Code: 400

InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

568
 AWS Lambda Guía para desarrolladores
PublishVersion

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

569
 AWS Lambda Guía para desarrolladores
PutFunctionConcurrency

PutFunctionConcurrency
Sets the maximum number of simultaneous executions for a function, and reserves capacity for that
concurrency level.

Concurrency settings apply to the function as a whole, including all published versions and the unpublished
version. Reserving concurrency both ensures that your function has capacity to process the specified
number of events simultaneously, and prevents it from scaling beyond that level. Use GetFunction (p. 500)
to see the current setting for a function.

Use GetAccountSettings (p. 491) to see your Regional concurrency limit. You can reserve concurrency for
as many functions as you like, as long as you leave at least 100 simultaneous executions unreserved for
functions that aren't configured with a per-function limit. For more information, see Managing Concurrency.

Request Syntax
PUT /2017-10-31/functions/FunctionName/concurrency HTTP/1.1
Content-type: application/json

{
"ReservedConcurrentExecutions": number
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 570)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

ReservedConcurrentExecutions (p. 570)

The number of simultaneous executions to reserve for the function.

Type: Integer

Valid Range: Minimum value of 0.

Required: Yes

570
 AWS Lambda Guía para desarrolladores
PutFunctionConcurrency

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"ReservedConcurrentExecutions": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

ReservedConcurrentExecutions (p. 571)

The number of concurrent executions that are reserved for this function. For more information, see
Managing Concurrency.

Type: Integer

Valid Range: Minimum value of 0.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

571
 AWS Lambda Guía para desarrolladores
PutFunctionConcurrency

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

572
 AWS Lambda Guía para desarrolladores
PutFunctionEventInvokeConfig

PutFunctionEventInvokeConfig
Configures options for asynchronous invocation on a function, version, or alias. If a configuration
already exists for a function, version, or alias, this operation overwrites it. If you exclude any settings,
they are removed. To set one option without affecting existing settings for other options, use
PutFunctionEventInvokeConfig (p. 573).

By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains
events in a queue for up to six hours. When an event fails all processing attempts or stays in the
asynchronous invocation queue for too long, Lambda discards it. To retain discarded events, configure a
dead-letter queue with UpdateFunctionConfiguration (p. 605).

To send an invocation record to a queue, topic, function, or event bus, specify a destination. You can
configure separate destinations for successful invocations (on-success) and events that fail all processing
attempts (on-failure). You can configure destinations in addition to or instead of a dead-letter queue.

Request Syntax
PUT /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1
Content-type: application/json

{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 573)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 573)

A version number or alias name.

573
 AWS Lambda Guía para desarrolladores
PutFunctionEventInvokeConfig

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request accepts the following data in JSON format.

DestinationConfig (p. 573)

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

Required: No
MaximumEventAgeInSeconds (p. 573)

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

Required: No
MaximumRetryAttempts (p. 573)

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Required: No

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"FunctionArn": "string",
"LastModified": number,

574
 AWS Lambda Guía para desarrolladores
PutFunctionEventInvokeConfig

"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

DestinationConfig (p. 574)

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

FunctionArn (p. 574)

The Amazon Resource Name (ARN) of the function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 574)

The date and time that the configuration was last updated, in Unix time seconds.

Type: Timestamp
MaximumEventAgeInSeconds (p. 574)

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

MaximumRetryAttempts (p. 574)

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

575
 AWS Lambda Guía para desarrolladores
PutFunctionEventInvokeConfig

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

576
 AWS Lambda Guía para desarrolladores
PutProvisionedConcurrencyConfig

PutProvisionedConcurrencyConfig
Adds a provisioned concurrency configuration to a function's alias or version.

Request Syntax
PUT /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier HTTP/1.1
Content-type: application/json

{
"ProvisionedConcurrentExecutions": number
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 577)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 577)

The version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request accepts the following data in JSON format.

ProvisionedConcurrentExecutions (p. 577)

The amount of provisioned concurrency to allocate for the version or alias.

Type: Integer

Valid Range: Minimum value of 1.

Required: Yes

577
 AWS Lambda Guía para desarrolladores
PutProvisionedConcurrencyConfig

Response Syntax
HTTP/1.1 202
Content-type: application/json

{
"AllocatedProvisionedConcurrentExecutions": number,
"AvailableProvisionedConcurrentExecutions": number,
"LastModified": "string",
"RequestedProvisionedConcurrentExecutions": number,
"Status": "string",
"StatusReason": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 202 response.

The following data is returned in JSON format by the service.

AllocatedProvisionedConcurrentExecutions (p. 578)

The amount of provisioned concurrency allocated.

Type: Integer

Valid Range: Minimum value of 0.

AvailableProvisionedConcurrentExecutions (p. 578)

The amount of provisioned concurrency available.

Type: Integer

Valid Range: Minimum value of 0.

LastModified (p. 578)

The date and time that a user last updated the configuration, in ISO 8601 format.

Type: String
RequestedProvisionedConcurrentExecutions (p. 578)

The amount of provisioned concurrency requested.

Type: Integer

Valid Range: Minimum value of 1.

Status (p. 578)

The status of the allocation process.

Type: String

Valid Values: IN_PROGRESS | READY | FAILED

StatusReason (p. 578)

For failed allocations, the reason that provisioned concurrency could not be allocated.

Type: String

578
 AWS Lambda Guía para desarrolladores
PutProvisionedConcurrencyConfig

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

579
 AWS Lambda Guía para desarrolladores
RemoveLayerVersionPermission

RemoveLayerVersionPermission
Removes a statement from the permissions policy for a version of an AWS Lambda layer. For more
information, see AddLayerVersionPermission (p. 449).

Request Syntax
DELETE /2018-10-31/layers/LayerName/versions/VersionNumber/policy/StatementId?
RevisionId=RevisionId HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

LayerName (p. 580)

The name or Amazon Resource Name (ARN) of the layer.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
RevisionId (p. 580)

Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a
policy that has changed since you last read it.
StatementId (p. 580)

The identifier that was specified when the statement was added.

Length Constraints: Minimum length of 1. Maximum length of 100.

Pattern: ([a-zA-Z0-9-_]+)
VersionNumber (p. 580)

The version number.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

580
 AWS Lambda Guía para desarrolladores
RemoveLayerVersionPermission

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

581
 AWS Lambda Guía para desarrolladores
RemovePermission

RemovePermission
Revokes function-use permission from an AWS service or another account. You can get the ID of the
statement from the output of GetPolicy (p. 522).

Request Syntax
DELETE /2015-03-31/functions/FunctionName/policy/StatementId?
Qualifier=Qualifier&RevisionId=RevisionId HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 582)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 582)

Specify a version or alias to remove permissions from a published version of the function.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)
RevisionId (p. 582)

Only update the policy if the revision ID matches the ID that's specified. Use this option to avoid
modifying a policy that has changed since you last read it.
StatementId (p. 582)

Statement ID of the permission to remove.

Length Constraints: Minimum length of 1. Maximum length of 100.

Pattern: ([a-zA-Z0-9-_.]+)

Request Body
The request does not have a request body.

582
 AWS Lambda Guía para desarrolladores
RemovePermission

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

583
 AWS Lambda Guía para desarrolladores
TagResource

TagResource
Adds tags to a function.

Request Syntax
POST /2017-03-31/tags/ARN HTTP/1.1
Content-type: application/json

{
"Tags": {
"string" : "string"
}
}

URI Request Parameters

The request requires the following URI parameters.

ARN (p. 584)

The function's Amazon Resource Name (ARN).

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

Tags (p. 584)

A list of tags to apply to the function.

Type: String to string map

Required: Yes

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

584
 AWS Lambda Guía para desarrolladores
TagResource

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

585
 AWS Lambda Guía para desarrolladores
UntagResource

UntagResource
Removes tags from a function.

Request Syntax
DELETE /2017-03-31/tags/ARN?tagKeys=TagKeys HTTP/1.1

URI Request Parameters

The request requires the following URI parameters.

ARN (p. 586)

The function's Amazon Resource Name (ARN).

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
TagKeys (p. 586)

A list of tag keys to remove from the function.

Request Body
The request does not have a request body.

Response Syntax
HTTP/1.1 204

Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

586
 AWS Lambda Guía para desarrolladores
UntagResource

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

587
 AWS Lambda Guía para desarrolladores
UpdateAlias

UpdateAlias
Updates the configuration of a Lambda function alias.

Request Syntax
PUT /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1
Content-type: application/json

{
"Description": "string",
"FunctionVersion": "string",
"RevisionId": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 588)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Name (p. 588)

The name of the alias.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)

Request Body
The request accepts the following data in JSON format.

Description (p. 588)

A description of the alias.

588
 AWS Lambda Guía para desarrolladores
UpdateAlias

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
FunctionVersion (p. 588)

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)

Required: No
RevisionId (p. 588)

Only update the alias if the revision ID matches the ID that's specified. Use this option to avoid
modifying an alias that has changed since you last read it.

Type: String

Required: No
RoutingConfig (p. 588)

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

Required: No

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"AliasArn": "string",
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RevisionId": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

AliasArn (p. 589)

The Amazon Resource Name (ARN) of the alias.

589
 AWS Lambda Guía para desarrolladores
UpdateAlias

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
Description (p. 589)

A description of the alias.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

FunctionVersion (p. 589)

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
Name (p. 589)

The name of the alias.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 589)

A unique identifier that changes when you update the alias.

Type: String
RoutingConfig (p. 589)

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

590
 AWS Lambda Guía para desarrolladores
UpdateAlias

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

591
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

UpdateEventSourceMapping
Updates an event source mapping. You can change the function that AWS Lambda invokes, or pause
invocation and resume later from the same location.

The following error handling options are only available for stream sources (DynamoDB and Kinesis):

• BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
• DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
• MaximumRecordAgeInSeconds - Discard records older than the specified age.
• MaximumRetryAttempts - Discard records after the specified number of retries.
• ParallelizationFactor - Process multiple batches from each shard concurrently.

Request Syntax
PUT /2015-03-31/event-source-mappings/UUID HTTP/1.1
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"Enabled": boolean,
"FunctionName": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number
}

URI Request Parameters

The request requires the following URI parameters.

UUID (p. 592)

The identifier of the event source mapping.

Request Body
The request accepts the following data in JSON format.

BatchSize (p. 592)

The maximum number of items to retrieve in a single batch.

• Amazon Kinesis - Default 100. Max 10,000.
• Amazon DynamoDB Streams - Default 100. Max 1,000.
• Amazon Simple Queue Service - Default 10. Max 10.

592
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

Required: No
BisectBatchOnFunctionError (p. 592)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean

Required: No
DestinationConfig (p. 592)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

Required: No
Enabled (p. 592)

Disables the event source mapping to pause polling and invocation.

Type: Boolean

Required: No
FunctionName (p. 592)

The name of the Lambda function.

Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Version or Alias ARN - arn:aws:lambda:us-
west-2:123456789012:function:MyFunction:PROD.
• Partial ARN - 123456789012:function:MyFunction.

The length constraint applies only to the full ARN. If you specify only the function name, it's limited to
64 characters in length.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
MaximumBatchingWindowInSeconds (p. 592)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

Required: No

593
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

MaximumRecordAgeInSeconds (p. 592)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

Required: No
MaximumRetryAttempts (p. 592)

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

Required: No
ParallelizationFactor (p. 592)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

Required: No

Response Syntax
HTTP/1.1 202
Content-type: application/json

{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"EventSourceArn": "string",
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"State": "string",
"StateTransitionReason": "string",
"UUID": "string"
}

Response Elements
If the action is successful, the service sends back an HTTP 202 response.

594
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

The following data is returned in JSON format by the service.

BatchSize (p. 594)

The maximum number of items to retrieve in a single batch.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

BisectBatchOnFunctionError (p. 594)

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean
DestinationConfig (p. 594)

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

EventSourceArn (p. 594)

The Amazon Resource Name (ARN) of the event source.

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
FunctionArn (p. 594)

The ARN of the Lambda function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 594)

The date that the event source mapping was last updated, or its state changed, in Unix time seconds.

Type: Timestamp
LastProcessingResult (p. 594)

The result of the last AWS Lambda invocation of your Lambda function.

Type: String
MaximumBatchingWindowInSeconds (p. 594)

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

MaximumRecordAgeInSeconds (p. 594)

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

595
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

MaximumRetryAttempts (p. 594)

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

ParallelizationFactor (p. 594)

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

State (p. 594)

The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.

Type: String
StateTransitionReason (p. 594)

Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.

Type: String
UUID (p. 594)

The identifier of the event source mapping.

Type: String

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceInUseException

The operation conflicts with the resource's availability. For example, you attempted to update an
EventSource Mapping in CREATING, or tried to delete a EventSource mapping currently in the
UPDATING state.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

596
 AWS Lambda Guía para desarrolladores
UpdateEventSourceMapping

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

597
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

UpdateFunctionCode
Updates a Lambda function's code.

The function's code is locked when you publish a version. You can't modify the code of a published version,
only the unpublished version.

Request Syntax
PUT /2015-03-31/functions/FunctionName/code HTTP/1.1
Content-type: application/json

{
"DryRun": boolean,
"Publish": boolean,
"RevisionId": "string",
"S3Bucket": "string",
"S3Key": "string",
"S3ObjectVersion": "string",
"ZipFile": blob
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 598)

The name of the Lambda function.

Name formats
• Function name - my-function.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

DryRun (p. 598)

Set to true to validate the request parameters and access permissions without modifying the function
code.

Type: Boolean

Required: No

598
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

Publish (p. 598)

Set to true to publish a new version of the function after updating the code. This has the same effect as
calling PublishVersion (p. 563) separately.

Type: Boolean

Required: No
RevisionId (p. 598)

Only update the function if the revision ID matches the ID that's specified. Use this option to avoid
modifying a function that has changed since you last read it.

Type: String

Required: No
S3Bucket (p. 598)

An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different
AWS account.

Type: String

Length Constraints: Minimum length of 3. Maximum length of 63.

Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$

Required: No
S3Key (p. 598)

The Amazon S3 key of the deployment package.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
S3ObjectVersion (p. 598)

For versioned objects, the version of the deployment package object to use.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
ZipFile (p. 598)

The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the
encoding for you.

Type: Base64-encoded binary data object

Required: No

Response Syntax
HTTP/1.1 200
Content-type: application/json

599
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

CodeSha256 (p. 599)

The SHA256 hash of the function's deployment package.

Type: String
CodeSize (p. 599)

The size of the function's deployment package, in bytes.

600
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

Type: Long
DeadLetterConfig (p. 599)

The function's dead letter queue.

Type: DeadLetterConfig (p. 625) object

Description (p. 599)

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Environment (p. 599)

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

FunctionArn (p. 599)

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionName (p. 599)

The name of the function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 599)

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+
KMSKeyArn (p. 599)

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
LastModified (p. 599)

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String

601
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

LastUpdateStatus (p. 599)

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

Type: String

Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 599)

The reason for the last update that was performed on the function.

Type: String
LastUpdateStatusReasonCode (p. 599)

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
Layers (p. 599)

The function's layers.

Type: Array of Layer (p. 642) objects

MasterArn (p. 599)

For Lambda@Edge functions, the ARN of the master function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
MemorySize (p. 599)

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

RevisionId (p. 599)

The latest updated revision of the function or alias.

Type: String
Role (p. 599)

The function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Runtime (p. 599)

The runtime environment for the Lambda function.

Type: String

602
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
State (p. 599)

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 599)

The reason for the function's current state.

Type: String
StateReasonCode (p. 599)

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 599)

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

TracingConfig (p. 599)

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Version (p. 599)

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
VpcConfig (p. 599)

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

Errors
CodeStorageExceededException

You have exceeded your maximum total code size per account. Learn more

603
 AWS Lambda Guía para desarrolladores
UpdateFunctionCode

HTTP Status Code: 400

InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

604
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

UpdateFunctionConfiguration
Modify the version-specific settings of a Lambda function.

When you update a function, Lambda provisions an instance of the function and its supporting resources.
If your function connects to a VPC, this process can take a minute. During this time, you can't modify
the function, but you can still invoke it. The LastUpdateStatus, LastUpdateStatusReason, and
LastUpdateStatusReasonCode fields in the response from GetFunctionConfiguration (p. 505) indicate
when the update is complete and the function is processing events with the new configuration. For more
information, see Function States.

These settings can vary between versions of a function and are locked when you publish a version. You
can't modify the configuration of a published version, only the unpublished version.

To configure function concurrency, use PutFunctionConcurrency (p. 570). To grant invoke permissions to
an account or AWS service, use AddPermission (p. 452).

Request Syntax
PUT /2015-03-31/functions/FunctionName/configuration HTTP/1.1
Content-type: application/json

{
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Variables": {
"string" : "string"
}
},
"Handler": "string",
"KMSKeyArn": "string",
"Layers": [ "string" ],
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ]
}
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 605)

The name of the Lambda function.

Name formats
• Function name - my-function.

605
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.

• Partial ARN - 123456789012:function:my-function.

The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Request Body
The request accepts the following data in JSON format.

DeadLetterConfig (p. 605)

A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous
events when they fail processing. For more information, see Dead Letter Queues.

Type: DeadLetterConfig (p. 625) object

Required: No
Description (p. 605)

A description of the function.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
Environment (p. 605)

Environment variables that are accessible from function code during execution.

Type: Environment (p. 627) object

Required: No
Handler (p. 605)

The name of the method within your code that Lambda calls to execute your function. The format
includes the file name. It can also include namespaces and other qualifiers, depending on the runtime.
For more information, see Programming Model.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+

Required: No
KMSKeyArn (p. 605)

The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's
environment variables. If it's not provided, AWS Lambda uses a default service key.

Type: String

606
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()

Required: No
Layers (p. 605)

A list of function layers to add to the function's execution environment. Specify each layer by its ARN,
including the version.

Type: Array of strings

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+

Required: No
MemorySize (p. 605)

The amount of memory that your function has access to. Increasing the function's memory also
increases its CPU allocation. The default value is 128 MB. The value must be a multiple of 64 MB.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

Required: No
RevisionId (p. 605)

Only update the function if the revision ID matches the ID that's specified. Use this option to avoid
modifying a function that has changed since you last read it.

Type: String

Required: No
Role (p. 605)

The Amazon Resource Name (ARN) of the function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+

Required: No
Runtime (p. 605)

The identifier of the function's runtime.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

Required: No
Timeout (p. 605)

The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds.
The maximum allowed value is 900 seconds.

Type: Integer

607
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

Valid Range: Minimum value of 1.

Required: No
TracingConfig (p. 605)

Set Mode to Active to sample and trace a subset of incoming requests with AWS X-Ray.

Type: TracingConfig (p. 652) object

Required: No
VpcConfig (p. 605)

For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in
the VPC. When you connect a function to a VPC, it can only access resources and the internet through
that VPC. For more information, see VPC Settings.

Type: VpcConfig (p. 654) object

Required: No

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"CodeSha256": "string",
"CodeSize": number,
"DeadLetterConfig": {
"TargetArn": "string"
},
"Description": "string",
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
"FunctionArn": "string",
"FunctionName": "string",
"Handler": "string",
"KMSKeyArn": "string",
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
"MemorySize": number,
"RevisionId": "string",
"Role": "string",
"Runtime": "string",
"State": "string",
"StateReason": "string",

608
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

CodeSha256 (p. 608)

The SHA256 hash of the function's deployment package.

Type: String
CodeSize (p. 608)

The size of the function's deployment package, in bytes.

Type: Long
DeadLetterConfig (p. 608)

The function's dead letter queue.

Type: DeadLetterConfig (p. 625) object

Description (p. 608)

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Environment (p. 608)

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

FunctionArn (p. 608)

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
FunctionName (p. 608)

The name of the function.

Type: String

609
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

Length Constraints: Minimum length of 1. Maximum length of 170.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 608)

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+
KMSKeyArn (p. 608)

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
LastModified (p. 608)

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String
LastUpdateStatus (p. 608)

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

Type: String

Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 608)

The reason for the last update that was performed on the function.

Type: String
LastUpdateStatusReasonCode (p. 608)

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
Layers (p. 608)

The function's layers.

Type: Array of Layer (p. 642) objects

MasterArn (p. 608)

For Lambda@Edge functions, the ARN of the master function.

Type: String

610
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
MemorySize (p. 608)

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

RevisionId (p. 608)

The latest updated revision of the function or alias.

Type: String
Role (p. 608)

The function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Runtime (p. 608)

The runtime environment for the Lambda function.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided
State (p. 608)

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 608)

The reason for the function's current state.

Type: String
StateReasonCode (p. 608)

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 608)

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

611
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

TracingConfig (p. 608)

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Version (p. 608)

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)
VpcConfig (p. 608)

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

PreconditionFailedException

The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

HTTP Status Code: 412

ResourceConflictException

The resource already exists, or another operation is in progress.

HTTP Status Code: 409

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

612
 AWS Lambda Guía para desarrolladores
UpdateFunctionConfiguration

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

613
 AWS Lambda Guía para desarrolladores
UpdateFunctionEventInvokeConfig

UpdateFunctionEventInvokeConfig
Updates the configuration for asynchronous invocation for a function, version, or alias.

To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig (p. 573).

Request Syntax
POST /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1
Content-type: application/json

{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}

URI Request Parameters

The request requires the following URI parameters.

FunctionName (p. 614)

The name of the Lambda function, version, or alias.

Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.

You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Qualifier (p. 614)

A version number or alias name.

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (|[a-zA-Z0-9$_-]+)

Request Body
The request accepts the following data in JSON format.

614
 AWS Lambda Guía para desarrolladores
UpdateFunctionEventInvokeConfig

DestinationConfig (p. 614)

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

Required: No
MaximumEventAgeInSeconds (p. 614)

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

Required: No
MaximumRetryAttempts (p. 614)

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Required: No

Response Syntax
HTTP/1.1 200
Content-type: application/json

{
"DestinationConfig": {
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
"Destination": "string"
}
},
"FunctionArn": "string",
"LastModified": number,
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}

Response Elements
If the action is successful, the service sends back an HTTP 200 response.

The following data is returned in JSON format by the service.

615
 AWS Lambda Guía para desarrolladores
UpdateFunctionEventInvokeConfig

DestinationConfig (p. 615)

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

FunctionArn (p. 615)

The Amazon Resource Name (ARN) of the function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
LastModified (p. 615)

The date and time that the configuration was last updated, in Unix time seconds.

Type: Timestamp
MaximumEventAgeInSeconds (p. 615)

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

MaximumRetryAttempts (p. 615)

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Errors
InvalidParameterValueException

One of the parameters in the request is invalid.

HTTP Status Code: 400

ResourceNotFoundException

The resource specified in the request does not exist.

HTTP Status Code: 404

ServiceException

The AWS Lambda service encountered an internal error.

HTTP Status Code: 500

616
 AWS Lambda Guía para desarrolladores
Data Types

TooManyRequestsException

The request throughput limit was exceeded.

HTTP Status Code: 429

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3

Data Types
The following data types are supported:

• AccountLimit (p. 619)

• AccountUsage (p. 620)
• AliasConfiguration (p. 621)
• AliasRoutingConfiguration (p. 623)
• Concurrency (p. 624)
• DeadLetterConfig (p. 625)
• DestinationConfig (p. 626)
• Environment (p. 627)
• EnvironmentError (p. 628)
• EnvironmentResponse (p. 629)
• EventSourceMappingConfiguration (p. 630)
• FunctionCode (p. 633)
• FunctionCodeLocation (p. 634)
• FunctionConfiguration (p. 635)
• FunctionEventInvokeConfig (p. 640)
• Layer (p. 642)
• LayersListItem (p. 643)
• LayerVersionContentInput (p. 644)
• LayerVersionContentOutput (p. 645)
• LayerVersionsListItem (p. 646)
• OnFailure (p. 648)
• OnSuccess (p. 649)
• ProvisionedConcurrencyConfigListItem (p. 650)

617
 AWS Lambda Guía para desarrolladores
Data Types

• TracingConfig (p. 652)

• TracingConfigResponse (p. 653)
• VpcConfig (p. 654)
• VpcConfigResponse (p. 655)

618
 AWS Lambda Guía para desarrolladores
AccountLimit

AccountLimit
Limits that are related to concurrency and storage. All file and storage sizes are in bytes.

Contents
CodeSizeUnzipped

The maximum size of a function's deployment package and layers when they're extracted.

Type: Long

Required: No
CodeSizeZipped

The maximum size of a deployment package when it's uploaded directly to AWS Lambda. Use Amazon
S3 for larger files.

Type: Long

Required: No
ConcurrentExecutions

The maximum number of simultaneous function executions.

Type: Integer

Required: No
TotalCodeSize

The amount of storage space that you can use for all deployment packages and layer archives.

Type: Long

Required: No
UnreservedConcurrentExecutions

The maximum number of simultaneous function executions, minus the capacity that's reserved for
individual functions with PutFunctionConcurrency (p. 570).

Type: Integer

Valid Range: Minimum value of 0.

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

619
 AWS Lambda Guía para desarrolladores
AccountUsage

AccountUsage
The number of functions and amount of storage in use.

Contents
FunctionCount

The number of Lambda functions.

Type: Long

Required: No
TotalCodeSize

The amount of storage space, in bytes, that's being used by deployment packages and layer archives.

Type: Long

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

620
 AWS Lambda Guía para desarrolladores
AliasConfiguration

AliasConfiguration
Provides configuration information about a Lambda function alias.

Contents
AliasArn

The Amazon Resource Name (ARN) of the alias.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
Description

A description of the alias.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
FunctionVersion

The function version that the alias invokes.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)

Required: No
Name

The name of the alias.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 128.

Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)

Required: No
RevisionId

A unique identifier that changes when you update the alias.

Type: String

Required: No
RoutingConfig

The routing configuration of the alias.

Type: AliasRoutingConfiguration (p. 623) object

621
 AWS Lambda Guía para desarrolladores
AliasConfiguration

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

622
 AWS Lambda Guía para desarrolladores
AliasRoutingConfiguration

AliasRoutingConfiguration
The traffic-shifting configuration of a Lambda function alias.

Contents
AdditionalVersionWeights

The name of the second alias, and the percentage of traffic that's routed to it.

Type: String to double map

Key Length Constraints: Minimum length of 1. Maximum length of 1024.

Key Pattern: [0-9]+

Valid Range: Minimum value of 0.0. Maximum value of 1.0.

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

623
 AWS Lambda Guía para desarrolladores
Concurrency

Concurrency
Contents
ReservedConcurrentExecutions

The number of concurrent executions that are reserved for this function. For more information, see
Managing Concurrency.

Type: Integer

Valid Range: Minimum value of 0.

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

624
 AWS Lambda Guía para desarrolladores
DeadLetterConfig

DeadLetterConfig
The dead-letter queue for failed asynchronous invocations.

Contents
TargetArn

The Amazon Resource Name (ARN) of an Amazon SQS queue or Amazon SNS topic.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

625
 AWS Lambda Guía para desarrolladores
DestinationConfig

DestinationConfig
A configuration object that specifies the destination of an event after Lambda processes it.

Contents
OnFailure

The destination configuration for failed invocations.

Type: OnFailure (p. 648) object

Required: No
OnSuccess

The destination configuration for successful invocations.

Type: OnSuccess (p. 649) object

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

626
 AWS Lambda Guía para desarrolladores
Environment

Environment
A function's environment variable settings.

Contents
Variables

Environment variable key-value pairs.

Type: String to string map

Key Pattern: [a-zA-Z]([a-zA-Z0-9_])+

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

627
 AWS Lambda Guía para desarrolladores
EnvironmentError

EnvironmentError
Error messages for environment variables that couldn't be applied.

Contents
ErrorCode

The error code.

Type: String

Required: No
Message

The error message.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

628
 AWS Lambda Guía para desarrolladores
EnvironmentResponse

EnvironmentResponse
The results of an operation to update or read environment variables. If the operation is successful, the
response contains the environment variables. If it failed, the response contains details about the error.

Contents
Error

Error messages for environment variables that couldn't be applied.

Type: EnvironmentError (p. 628) object

Required: No
Variables

Environment variable key-value pairs.

Type: String to string map

Key Pattern: [a-zA-Z]([a-zA-Z0-9_])+

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

629
 AWS Lambda Guía para desarrolladores
EventSourceMappingConfiguration

EventSourceMappingConfiguration
A mapping between an AWS resource and an AWS Lambda function. See
CreateEventSourceMapping (p. 460) for details.

Contents
BatchSize

The maximum number of items to retrieve in a single batch.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10000.

Required: No
BisectBatchOnFunctionError

(Streams) If the function returns an error, split the batch in two and retry.

Type: Boolean

Required: No
DestinationConfig

(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.

Type: DestinationConfig (p. 626) object

Required: No
EventSourceArn

The Amazon Resource Name (ARN) of the event source.

Type: String

Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)

Required: No
FunctionArn

The ARN of the Lambda function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
LastModified

The date that the event source mapping was last updated, or its state changed, in Unix time seconds.

Type: Timestamp

Required: No

630
 AWS Lambda Guía para desarrolladores
EventSourceMappingConfiguration

LastProcessingResult

The result of the last AWS Lambda invocation of your Lambda function.

Type: String

Required: No
MaximumBatchingWindowInSeconds

(Streams) The maximum amount of time to gather records before invoking the function, in seconds.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 300.

Required: No
MaximumRecordAgeInSeconds

(Streams) The maximum age of a record that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 604800.

Required: No
MaximumRetryAttempts

(Streams) The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 10000.

Required: No
ParallelizationFactor

(Streams) The number of batches to process from each shard concurrently.

Type: Integer

Valid Range: Minimum value of 1. Maximum value of 10.

Required: No
State

The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.

Type: String

Required: No
StateTransitionReason

Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.

Type: String

Required: No

631
 AWS Lambda Guía para desarrolladores
EventSourceMappingConfiguration

UUID

The identifier of the event source mapping.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

632
 AWS Lambda Guía para desarrolladores
FunctionCode

FunctionCode
The code for the Lambda function. You can specify either an object in Amazon S3, or upload a deployment
package directly.

Contents
S3Bucket

An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different
AWS account.

Type: String

Length Constraints: Minimum length of 3. Maximum length of 63.

Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$

Required: No
S3Key

The Amazon S3 key of the deployment package.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
S3ObjectVersion

For versioned objects, the version of the deployment package object to use.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
ZipFile

The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the
encoding for you.

Type: Base64-encoded binary data object

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

633
 AWS Lambda Guía para desarrolladores
FunctionCodeLocation

FunctionCodeLocation
Details about a function's deployment package.

Contents
Location

A presigned URL that you can use to download the deployment package.

Type: String

Required: No
RepositoryType

The service that's hosting the file.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

634
 AWS Lambda Guía para desarrolladores
FunctionConfiguration

FunctionConfiguration
Details about a function's configuration.

Contents
CodeSha256

The SHA256 hash of the function's deployment package.

Type: String

Required: No
CodeSize

The size of the function's deployment package, in bytes.

Type: Long

Required: No
DeadLetterConfig

The function's dead letter queue.

Type: DeadLetterConfig (p. 625) object

Required: No
Description

The function's description.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
Environment

The function's environment variables.

Type: EnvironmentResponse (p. 629) object

Required: No
FunctionArn

The function's Amazon Resource Name (ARN).

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
FunctionName

The name of the function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 170.

635
 AWS Lambda Guía para desarrolladores
FunctionConfiguration

Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
Handler

The function that Lambda calls to begin executing your function.

Type: String

Length Constraints: Maximum length of 128.

Pattern: [^\s]+

Required: No
KMSKeyArn

The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.

Type: String

Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()

Required: No
LastModified

The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:[Link]).

Type: String

Required: No
LastUpdateStatus

The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.

Type: String

Valid Values: Successful | Failed | InProgress

Required: No
LastUpdateStatusReason

The reason for the last update that was performed on the function.

Type: String

Required: No
LastUpdateStatusReasonCode

The reason code for the last update that was performed on the function.

Type: String

Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup

Required: No

636
 AWS Lambda Guía para desarrolladores
FunctionConfiguration

Layers

The function's layers.

Type: Array of Layer (p. 642) objects

Required: No
MasterArn

For Lambda@Edge functions, the ARN of the master function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
MemorySize

The memory that's allocated to the function.

Type: Integer

Valid Range: Minimum value of 128. Maximum value of 3008.

Required: No
RevisionId

The latest updated revision of the function or alias.

Type: String

Required: No
Role

The function's execution role.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+

Required: No
Runtime

The runtime environment for the Lambda function.

Type: String

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

Required: No
State

The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.

Type: String

Valid Values: Pending | Active | Inactive | Failed

637
 AWS Lambda Guía para desarrolladores
FunctionConfiguration

Required: No
StateReason

The reason for the function's current state.

Type: String

Required: No
StateReasonCode

The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.

Type: String

Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup

Required: No
Timeout

The amount of time that Lambda allows a function to run before stopping it.

Type: Integer

Valid Range: Minimum value of 1.

Required: No
TracingConfig

The function's AWS X-Ray tracing configuration.

Type: TracingConfigResponse (p. 653) object

Required: No
Version

The version of the Lambda function.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Pattern: (\$LATEST|[0-9]+)

Required: No
VpcConfig

The function's networking configuration.

Type: VpcConfigResponse (p. 655) object

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

638
 AWS Lambda Guía para desarrolladores
FunctionConfiguration

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

639
 AWS Lambda Guía para desarrolladores
FunctionEventInvokeConfig

FunctionEventInvokeConfig
Contents
DestinationConfig

A destination for events after they have been sent to a function for processing.

Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

Type: DestinationConfig (p. 626) object

Required: No
FunctionArn

The Amazon Resource Name (ARN) of the function.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
LastModified

The date and time that the configuration was last updated, in Unix time seconds.

Type: Timestamp

Required: No
MaximumEventAgeInSeconds

The maximum age of a request that Lambda sends to a function for processing.

Type: Integer

Valid Range: Minimum value of 60. Maximum value of 21600.

Required: No
MaximumRetryAttempts

The maximum number of times to retry when the function returns an error.

Type: Integer

Valid Range: Minimum value of 0. Maximum value of 2.

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

640
 AWS Lambda Guía para desarrolladores
FunctionEventInvokeConfig

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

641
 AWS Lambda Guía para desarrolladores
Layer

Layer
An AWS Lambda layer.

Contents
Arn

The Amazon Resource Name (ARN) of the function layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+

Required: No
CodeSize

The size of the layer archive in bytes.

Type: Long

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

642
 AWS Lambda Guía para desarrolladores
LayersListItem

LayersListItem
Details about an AWS Lambda layer.

Contents
LatestMatchingVersion

The newest version of the layer.

Type: LayerVersionsListItem (p. 646) object

Required: No
LayerArn

The Amazon Resource Name (ARN) of the function layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+

Required: No
LayerName

The name of the layer.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

643
 AWS Lambda Guía para desarrolladores
LayerVersionContentInput

LayerVersionContentInput
A ZIP archive that contains the contents of an AWS Lambda layer. You can specify either an Amazon S3
location, or upload a layer archive directly.

Contents
S3Bucket

The Amazon S3 bucket of the layer archive.

Type: String

Length Constraints: Minimum length of 3. Maximum length of 63.

Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$

Required: No
S3Key

The Amazon S3 key of the layer archive.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
S3ObjectVersion

For versioned objects, the version of the layer archive object to use.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 1024.

Required: No
ZipFile

The base64-encoded contents of the layer archive. AWS SDK and AWS CLI clients handle the
encoding for you.

Type: Base64-encoded binary data object

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

644
 AWS Lambda Guía para desarrolladores
LayerVersionContentOutput

LayerVersionContentOutput
Details about a version of an AWS Lambda layer.

Contents
CodeSha256

The SHA-256 hash of the layer archive.

Type: String

Required: No
CodeSize

The size of the layer archive in bytes.

Type: Long

Required: No
Location

A link to the layer archive in Amazon S3 that is valid for 10 minutes.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

645
 AWS Lambda Guía para desarrolladores
LayerVersionsListItem

LayerVersionsListItem
Details about a version of an AWS Lambda layer.

Contents
CompatibleRuntimes

The layer's compatible runtimes.

Type: Array of strings

Array Members: Maximum number of 5 items.

Valid Values: nodejs10.x | nodejs12.x | java8 | java11 | python2.7 | python3.6

| python3.7 | python3.8 | dotnetcore2.1 | dotnetcore3.1 | go1.x | ruby2.5 |
ruby2.7 | provided

Required: No
CreatedDate

The date that the version was created, in ISO 8601 format. For example,
2018-11-27T15:10:45.123+0000.

Type: String

Required: No
Description

The description of the version.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 256.

Required: No
LayerVersionArn

The ARN of the layer version.

Type: String

Length Constraints: Minimum length of 1. Maximum length of 140.

Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+

Required: No
LicenseInfo

The layer's open-source license.

Type: String

Length Constraints: Maximum length of 512.

Required: No
Version

The version number.

646
 AWS Lambda Guía para desarrolladores
LayerVersionsListItem

Type: Long

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

647
 AWS Lambda Guía para desarrolladores
OnFailure

OnFailure
A destination for events that failed processing.

Contents
Destination

The Amazon Resource Name (ARN) of the destination resource.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 350.

Pattern: ^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

648
 AWS Lambda Guía para desarrolladores
OnSuccess

OnSuccess
A destination for events that were processed successfully.

Contents
Destination

The Amazon Resource Name (ARN) of the destination resource.

Type: String

Length Constraints: Minimum length of 0. Maximum length of 350.

Pattern: ^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

649
 AWS Lambda Guía para desarrolladores
ProvisionedConcurrencyConfigListItem

ProvisionedConcurrencyConfigListItem
Details about the provisioned concurrency configuration for a function alias or version.

Contents
AllocatedProvisionedConcurrentExecutions

The amount of provisioned concurrency allocated.

Type: Integer

Valid Range: Minimum value of 0.

Required: No
AvailableProvisionedConcurrentExecutions

The amount of provisioned concurrency available.

Type: Integer

Valid Range: Minimum value of 0.

Required: No
FunctionArn

The Amazon Resource Name (ARN) of the alias or version.

Type: String

Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?

Required: No
LastModified

The date and time that a user last updated the configuration, in ISO 8601 format.

Type: String

Required: No
RequestedProvisionedConcurrentExecutions

The amount of provisioned concurrency requested.

Type: Integer

Valid Range: Minimum value of 1.

Required: No
Status

The status of the allocation process.

Type: String

Valid Values: IN_PROGRESS | READY | FAILED

Required: No

650
 AWS Lambda Guía para desarrolladores
ProvisionedConcurrencyConfigListItem

StatusReason

For failed allocations, the reason that provisioned concurrency could not be allocated.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

651
 AWS Lambda Guía para desarrolladores
TracingConfig

TracingConfig
The function's AWS X-Ray tracing configuration. To sample and record incoming requests, set Mode to
Active.

Contents
Mode

The tracing mode.

Type: String

Valid Values: Active | PassThrough

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

652
 AWS Lambda Guía para desarrolladores
TracingConfigResponse

TracingConfigResponse
The function's AWS X-Ray tracing configuration.

Contents
Mode

The tracing mode.

Type: String

Valid Values: Active | PassThrough

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

653
 AWS Lambda Guía para desarrolladores
VpcConfig

VpcConfig
The VPC security groups and subnets that are attached to a Lambda function. For more information, see
VPC Settings.

Contents
SecurityGroupIds

A list of VPC security groups IDs.

Type: Array of strings

Array Members: Maximum number of 5 items.

Required: No
SubnetIds

A list of VPC subnet IDs.

Type: Array of strings

Array Members: Maximum number of 16 items.

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

654
 AWS Lambda Guía para desarrolladores
VpcConfigResponse

VpcConfigResponse
The VPC security groups and subnets that are attached to a Lambda function.

Contents
SecurityGroupIds

A list of VPC security groups IDs.

Type: Array of strings

Array Members: Maximum number of 5 items.

Required: No
SubnetIds

A list of VPC subnet IDs.

Type: Array of strings

Array Members: Maximum number of 16 items.

Required: No
VpcId

The ID of the VPC.

Type: String

Required: No

See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:

• AWS SDK for C++

• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for Ruby V3

Errores de los certificados cuando se utiliza un SDK

Como los SDK de AWS utilizan certificados de CA desde su equipo, los cambios en los certificados en
los servidores de AWS pueden provocar errores de conexión cuando intentar usar un SDK. Puede evitar
estos errores manteniendo actualizados los certificados de CA de su equipo y el sistema operativo. Si
detecta este problema en un entorno corporativo y no administra su propio equipo, es posible que deba
pedir ayuda a un administrador con el proceso de actualización. La siguiente lista muestra las versiones
mínimas necesarias del sistema operativo y Java:

• Las versiones de Microsoft Windows con actualizaciones instaladas a partir de enero de 2005 o fechas
posteriores, contienen al menos uno de los CA necesarios en su lista de confianza.
• Mac OS X 10.4 con Java para Mac OS X 10.4 Release 5 (febrero de 2007), Mac OS X 10.5 (octubre de
2007) y las versiones posteriores contienen al menos uno de los CA necesarios en su lista de confianza.

655
 AWS Lambda Guía para desarrolladores
Errores de los certificados cuando se utiliza un SDK

• Red Hat Enterprise Linux 5 (marzo de 2007), 6 y 7 y CentOS 5, 6 y 7 contienen al menos uno de los CA
necesarios en su lista de confianza predeterminada.
• Java 1.4.2_12 (mayo de 2006), 5 Update 2 (marzo de 2005) y todas las versiones posteriores, incluido
Java 6 (diciembre de 2006), 7 y 8, contienen al menos uno de los CA necesarios en su lista de confianza
predeterminada.

Cuando obtenga acceso a los puntos de enlace de la consola de administración de AWS Lambda o de la
API de AWS Lambda, ya sea a través de un navegador o mediante programación, deberá asegurarse de
que las máquinas cliente admiten alguna de las siguientes entidades de certificación:

• Amazon Root CA 1
• Starfield Services Root Certificate Authority - G2
• Starfield Class 2 Certification Authority

Los certificados raíz de las primeras dos entidades están disponibles en Amazon Trust Services, aunque
mantener el equipo actualizado es la solución más sencilla. Para obtener más información sobre los
certificados proporcionados por ACM, consulte Preguntas frecuentes sobre AWS Certificate Manager.

656
 AWS Lambda Guía para desarrolladores

AWS Glossary
For the latest AWS terminology, see the AWS Glossary in the AWS General Reference.

657