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
Crear una función ....................................................................................................................... 3
Uso del diseñador .............................................................................................................. 4
Invocar la función de Lambda .............................................................................................. 4
Eliminar recursos ................................................................................................................ 6
Editor de código ......................................................................................................................... 7
Uso de archivos y carpetas .................................................................................................. 7
Trabajar con código ............................................................................................................ 9
Trabajar en modo de pantalla completa ............................................................................... 12
Trabajar con preferencias ................................................................................................... 12
AWS CLI ................................................................................................................................. 13
Requisitos previos ............................................................................................................. 13
Creación del rol de ejecución ............................................................................................. 13
Creación de la función ....................................................................................................... 15
Listado de las funciones Lambda de su cuenta ..................................................................... 17
Recuperar una función Lambda. ......................................................................................... 17
Eliminar recursos .............................................................................................................. 18
Conceptos ............................................................................................................................... 18
Función ........................................................................................................................... 18
Qualifier ........................................................................................................................... 18
Tiempo de ejecución ......................................................................................................... 19
Evento ............................................................................................................................. 19
Simultaneidad ................................................................................................................... 19
Trigger ............................................................................................................................ 20
Características .......................................................................................................................... 20
Modelo de programación .................................................................................................... 20
Paquete de implementación ............................................................................................... 22
Capas ............................................................................................................................. 22
Escalado ......................................................................................................................... 22
Controles de simultaneidad ................................................................................................ 23
Invocación asincrónica ....................................................................................................... 25
Mapeos de origen de eventos ............................................................................................ 26
Destinos .......................................................................................................................... 27
Proyectos de funciones ...................................................................................................... 28
Plantillas de aplicaciones ................................................................................................... 29
Herramientas ............................................................................................................................ 29
AWS Command Line Interface ............................................................................................ 29
Modelo de aplicación sin servidor de AWS ........................................................................... 29
CLI de SAM ..................................................................................................................... 30
Herramientas para crear código .......................................................................................... 30
Cuotas .................................................................................................................................... 31
Permisos ......................................................................................................................................... 33
Rol de ejecución ....................................................................................................................... 33
Creación de un rol de ejecución en la consola de IAM ............................................................ 35
Administración de roles con la API de IAM ........................................................................... 35
Políticas administradas para características de Lambda .......................................................... 36
Políticas basadas en recursos .................................................................................................... 37
Concesión de acceso a las funciones a los servicios de AWS .................................................. 39
Concesión de acceso a las funciones a otras cuentas ............................................................ 39
Concesión de acceso a las capas a otras cuentas ................................................................. 41
Limpieza de políticas basadas en recursos ........................................................................... 41

iii
 AWS Lambda Guía para desarrolladores

Políticas de usuario ................................................................................................................... 42

Desarrollo de funciones ..................................................................................................... 42
Desarrollo y uso de capas ................................................................................................. 45
Roles entre cuentas .......................................................................................................... 46
Claves de condición para la configuración de la VPC ............................................................ 46
Recursos y condiciones ............................................................................................................. 47
Funciones ........................................................................................................................ 48
Mapeos de origen de eventos ............................................................................................ 49
Capas ............................................................................................................................. 50
Límites de permisos .................................................................................................................. 50
Administración de funciones ............................................................................................................... 53
Consola de configuración ........................................................................................................... 54
Variables de entorno ................................................................................................................. 56
Variables de entorno de tiempo de ejecución ........................................................................ 58
Proteger variables de entorno ............................................................................................. 59
Configuración de variables de entorno con la API de Lambda .................................................. 60
Código de muestra y plantillas ............................................................................................ 61
Simultaneidad ........................................................................................................................... 62
Configuración de la simultaneidad reservada ........................................................................ 62
Configuración de simultaneidad aprovisionada ....................................................................... 64
Configuración de simultaneidad con la API de Lambda ........................................................... 67
Versiones ................................................................................................................................ 70
Administración de versiones con la API de Lambda ............................................................... 71
Uso de versiones .............................................................................................................. 71
Políticas de recursos ......................................................................................................... 72
Alias ....................................................................................................................................... 72
Administración de alias con la API de Lambda ...................................................................... 73
Uso de alias .................................................................................................................... 73
Políticas de recursos ......................................................................................................... 74
Configuración de direccionamiento de alias ........................................................................... 74
Capas ..................................................................................................................................... 76
Configuración de una función para usar capas ...................................................................... 76
Administración de capas .................................................................................................... 77
Inclusión de dependencias de biblioteca en una capa ............................................................. 79
Permisos de capa ............................................................................................................. 80
AWS CloudFormation y AWS SAM ...................................................................................... 80
Aplicaciones de muestra .................................................................................................... 81
Red ........................................................................................................................................ 81
Permisos de usuario y rol de ejecución ................................................................................ 82
Configuración del acceso a la VPC con la API de Lambda ...................................................... 83
Uso de claves de condición de IAM para la configuración de la VPC ......................................... 83
Acceso a Internet y a los servicios para funciones conectadas a la VPC .................................... 87
Ejemplos de configuraciones de VPC .................................................................................. 87
Base de datos .......................................................................................................................... 87
Uso de los permisos de la función para autenticación ............................................................. 88
Aplicación de muestra ....................................................................................................... 89
Sistema de archivos .................................................................................................................. 91
Configuración de un sistema de archivos y un punto de acceso ............................................... 92
Permisos de usuario y rol de ejecución ................................................................................ 93
Configurar el acceso al sistema de archivos con la API de Lambda .......................................... 93
AWS CloudFormation y AWS SAM ...................................................................................... 94
Aplicaciones de muestra .................................................................................................... 95
Etiquetas ................................................................................................................................. 95
Uso de etiquetas con AWS CLI .......................................................................................... 97
Requisitos de las claves y los valores de las etiquetas ........................................................... 98
Invocar funciones .............................................................................................................................. 99
Invocación síncrona ................................................................................................................. 100

iv
 AWS Lambda Guía para desarrolladores

Invocación asincrónica ............................................................................................................. 101

Configuración de la gestión de errores para la invocación asincrónica ..................................... 104
Configuración de destinos para invocación asincrónica ......................................................... 104
API de configuración de invocación asincrónica ................................................................... 106
Colas de mensajes fallidos ............................................................................................... 107
Mapeo de origen de eventos .................................................................................................... 109
Estados de función .................................................................................................................. 113
Escalado de funciones ............................................................................................................. 114
Control de errores ................................................................................................................... 119
SDK de Mobile para Android .................................................................................................... 121
Tutorial .......................................................................................................................... 122
Código de muestra .......................................................................................................... 127
Tiempos de ejecución de Lambda. .................................................................................................... 130
Contexto de ejecución ............................................................................................................. 132
Política de soporte del tiempo de ejecución ................................................................................ 132
Runtimes personalizados .......................................................................................................... 134
Uso de un tiempo de ejecución personalizado ..................................................................... 134
Creación de un tiempo de ejecución personalizado .............................................................. 134
Interfaz de tiempo de ejecución ................................................................................................. 136
Siguiente invocación ........................................................................................................ 136
Respuesta de la invocación .............................................................................................. 137
Error de invocación ......................................................................................................... 138
Error de inicialización ....................................................................................................... 138
Tutorial: tiempo de ejecución personalizado ................................................................................ 138
Requisitos previos ........................................................................................................... 138
Crear una función ........................................................................................................... 139
Crear una capa ............................................................................................................... 141
Actualización de la función ............................................................................................... 141
Actualización del tiempo de ejecución ................................................................................ 142
Uso compartido de la capa ............................................................................................... 143
Eliminar recursos ............................................................................................................ 143
Aplicaciones de Lambda .................................................................................................................. 144
Administración de aplicaciones .................................................................................................. 144
Monitorización de aplicaciones .......................................................................................... 145
Paneles personalizados de monitorización .......................................................................... 145
Tutorial: Crear una aplicación ................................................................................................... 147
Requisitos previos ........................................................................................................... 148
Cree una aplicación ......................................................................................................... 148
Describe cómo invocar la función. ..................................................................................... 149
Añadir un recurso de AWS ............................................................................................... 150
Actualizar el límite de permisos ......................................................................................... 152
Actualizar el código de la función ...................................................................................... 152
Pasos siguientes ............................................................................................................. 154
Solución de problemas ..................................................................................................... 154
Eliminar recursos ............................................................................................................ 155
Implementaciones continuas ..................................................................................................... 156
Ejemplo de plantilla de Lambda de AWS SAM .................................................................... 156
Casos de uso ......................................................................................................................... 157
Ejemplo 1: Amazon S3 envía eventos e invoca una función de Lambda ................................... 158
Ejemplo 2: AWS Lambda obtiene los eventos desde un flujo de Kinesis e invoca una función de
Lambda ......................................................................................................................... 158
Prácticas recomendadas .......................................................................................................... 159
Código de función ........................................................................................................... 159
Función de configuración .................................................................................................. 160
Métricas y alarmas .......................................................................................................... 161
Uso de secuencias .......................................................................................................... 161
Trabajar con otros servicios .............................................................................................................. 163

v
 AWS Lambda Guía para desarrolladores

Alexa ..................................................................................................................................... 165

API Gateway .......................................................................................................................... 165
Permisos ........................................................................................................................ 168
Administración de errores con una API de API Gateway ........................................................ 170
Elegir un tipo de API ....................................................................................................... 170
Aplicaciones de muestra .................................................................................................. 172
Tutorial .......................................................................................................................... 172
Código de muestra .......................................................................................................... 181
Proyecto de microservicio ................................................................................................. 183
Plantilla de muestra ......................................................................................................... 185
CloudTrail .............................................................................................................................. 185
Registros de CloudTrail .................................................................................................... 187
Tutorial .......................................................................................................................... 190
Código de muestra .......................................................................................................... 195
Eventos de CloudWatch ........................................................................................................... 196
Tutorial .......................................................................................................................... 198
Plantilla de muestra ......................................................................................................... 200
Programación de expresiones ........................................................................................... 201
Registros de CloudWatch ......................................................................................................... 202
CloudFormation ....................................................................................................................... 203
CloudFront (Lambda@Edge) ..................................................................................................... 205
CodeCommit .......................................................................................................................... 207
CodePipeline .......................................................................................................................... 208
Permisos ........................................................................................................................ 209
Tutorial .......................................................................................................................... 210
Cognito .................................................................................................................................. 215
Config .................................................................................................................................... 216
DynamoDB ............................................................................................................................. 216
Permisos de rol de ejecución ............................................................................................ 218
Configuración de una secuencia como origen de eventos ...................................................... 219
API de mapeo de origen de eventos .................................................................................. 220
Control de errores ........................................................................................................... 221
Métricas de Amazon CloudWatch ...................................................................................... 222
Tutorial .......................................................................................................................... 223
Código de muestra .......................................................................................................... 227
Plantilla de muestra ......................................................................................................... 230
EC2 ...................................................................................................................................... 231
Permisos ........................................................................................................................ 232
Tutorial: Instancias de spot ............................................................................................... 232
ElastiCache ............................................................................................................................ 241
Requisitos previos ........................................................................................................... 241
Creación del rol de ejecución ............................................................................................ 242
Creación de un clúster de ElastiCache ............................................................................... 242
Creación de un paquete de implementación ........................................................................ 242
Creación de la función de Lambda .................................................................................... 243
Prueba de la función de Lambda ....................................................................................... 243
Elastic Load Balancing ............................................................................................................. 244
EFS ...................................................................................................................................... 245
Conexiones .................................................................................................................... 246
Rendimiento ................................................................................................................... 246
IOPS ............................................................................................................................. 247
IoT ........................................................................................................................................ 247
IoT Events ............................................................................................................................. 248
Kinesis Firehose ..................................................................................................................... 249
Flujos de Kinesis ..................................................................................................................... 250
Configurar su flujo de datos y función. ............................................................................... 252
Permisos de rol de ejecución ............................................................................................ 252

vi
 AWS Lambda Guía para desarrolladores

Configuración de una secuencia como un origen de eventos ................................................. 253

API de mapeo de origen de eventos .................................................................................. 254
Control de errores ........................................................................................................... 256
Métricas de Amazon CloudWatch ...................................................................................... 257
Tutorial .......................................................................................................................... 257
Código de muestra .......................................................................................................... 261
Plantilla de muestra ......................................................................................................... 264
Lex ....................................................................................................................................... 265
Roles y permisos ............................................................................................................ 267
RDS ...................................................................................................................................... 268
Tutorial: Amazon RDS ..................................................................................................... 269
S3 ......................................................................................................................................... 272
Tutorial .......................................................................................................................... 273
Código de muestra .......................................................................................................... 280
Plantilla de muestra ......................................................................................................... 286
Lote S3 ................................................................................................................................. 287
Invocación de funciones de Lambda desde operaciones por lotes de Amazon S3 ...................... 288
SES ...................................................................................................................................... 288
SNS ...................................................................................................................................... 290
Tutorial .......................................................................................................................... 291
Código de muestra .......................................................................................................... 294
SQS ...................................................................................................................................... 296
Escalado y procesamiento ................................................................................................ 298
Configuración de una cola para el uso con Lambda ............................................................. 298
Permisos de rol de ejecución ............................................................................................ 298
Configuración de una cola como origen de eventos .............................................................. 299
API de mapeo de origen de eventos .................................................................................. 220
Tutorial .......................................................................................................................... 300
Código de muestra .......................................................................................................... 303
Plantilla de muestra ......................................................................................................... 306
Step Functions ........................................................................................................................ 307
Configuración de una máquina de estado como un origen de eventos ..................................... 307
Gestión de errores de función y servicio ............................................................................. 308
AWS CloudFormation y AWS SAM .................................................................................... 309
X-Ray .................................................................................................................................... 311
Permisos de rol de ejecución ............................................................................................ 312
El demonio de AWS X-Ray .............................................................................................. 313
Habilitación del seguimiento activo con la API de Lambda ..................................................... 313
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 313
Muestras ........................................................................................................................................ 315
Función en blanco ................................................................................................................... 316
Arquitectura y código de controlador .................................................................................. 317
Automatización de implementación con AWS CloudFormation y la AWS CLI ............................. 318
Instrumentación con el AWS X-Ray ................................................................................... 321
Administración de dependencias con capas ........................................................................ 322
Procesador de errores ............................................................................................................. 323
Arquitectura y estructura de eventos .................................................................................. 324
Instrumentación con AWS X-Ray ....................................................................................... 325
Plantilla de AWS CloudFormation y recursos adicionales ....................................................... 326
List manager .......................................................................................................................... 327
Arquitectura y estructura de eventos .................................................................................. 328
Instrumentación con AWS X-Ray ....................................................................................... 329
Plantillas de AWS CloudFormation y recursos adicionales ..................................................... 331
Uso de Node.js ............................................................................................................................... 332
Controlador ............................................................................................................................ 334
Controladores asincrónicos ............................................................................................... 335
Controladores no asincrónicos .......................................................................................... 335

vii
 AWS Lambda Guía para desarrolladores

Paquete de implementación ...................................................................................................... 336

Actualización de una función sin dependencias .................................................................... 336
Actualización de una función con dependencias adicionales .................................................. 337
Contexto ................................................................................................................................ 338
Registro ................................................................................................................................. 339
Visualización de registros en la Consola de administración de AWS ........................................ 340
Mediante AWS CLI .......................................................................................................... 341
Eliminación de registros ................................................................................................... 342
Errores .................................................................................................................................. 342
Tracing .................................................................................................................................. 344
Habilitación del seguimiento activo con la API de Lambda ..................................................... 346
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 347
Almacenamiento de dependencias en tiempo de ejecución en una capa .................................. 347
Uso de Python ................................................................................................................................ 349
Controlador ............................................................................................................................ 351
Paquete de implementación ...................................................................................................... 352
Requisitos previos ........................................................................................................... 352
Actualización de una función sin dependencias .................................................................... 352
Actualización de una función con dependencias adicionales .................................................. 353
Con un entorno virtual ..................................................................................................... 354
Contexto ................................................................................................................................ 355
Registro ................................................................................................................................. 357
Visualización de registros en la Consola de administración de AWS ........................................ 358
Mediante AWS CLI .......................................................................................................... 358
Eliminación de registros ................................................................................................... 360
Biblioteca de registro ....................................................................................................... 360
Errores .................................................................................................................................. 360
Tracing .................................................................................................................................. 361
Habilitación del seguimiento activo con la API de Lambda ..................................................... 364
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 365
Almacenamiento de dependencias en tiempo de ejecución en una capa .................................. 365
Uso de Ruby .................................................................................................................................. 367
Controlador ............................................................................................................................ 369
Paquete de implementación ...................................................................................................... 370
Actualización de una función sin dependencias .................................................................... 370
Actualización de una función con dependencias adicionales .................................................. 371
Contexto ................................................................................................................................ 371
Registro ................................................................................................................................. 372
Visualización de registros en la Consola de administración de AWS ........................................ 358
Mediante AWS CLI .......................................................................................................... 358
Eliminación de registros ................................................................................................... 360
Errores .................................................................................................................................. 376
Tracing .................................................................................................................................. 378
Habilitación del seguimiento activo con la API de Lambda ..................................................... 380
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 381
Almacenamiento de dependencias en tiempo de ejecución en una capa .................................. 381
Uso de Java ................................................................................................................................... 383
Aplicaciones de ejemplo ........................................................................................................... 384
Paquete de implementación ...................................................................................................... 386
Compilación de un paquete de implementación con Gradle ................................................... 388
Compilación de un paquete de implementación con Maven ................................................... 388
Carga de un paquete de implementación con la API de Lambda ............................................. 390
Carga de un paquete de implementación con AWS SAM ...................................................... 391
Controlador ............................................................................................................................ 392
Elección de los tipos de entrada y salida ............................................................................ 393
Interfaces de controlador .................................................................................................. 394
Ejemplo de código del controlador ..................................................................................... 395

viii
 AWS Lambda Guía para desarrolladores

Contexto ................................................................................................................................ 396

Contexto en aplicaciones de ejemplo ................................................................................. 398
Registro ................................................................................................................................. 398
Visualización de registros en la Consola de administración de AWS ........................................ 400
Mediante AWS CLI .......................................................................................................... 400
Eliminación de registros ................................................................................................... 402
Registro avanzado con Log4j 2 y SLF4J ............................................................................. 402
Código de registro de ejemplo .......................................................................................... 404
Errores .................................................................................................................................. 404
Ver la salida de errores ................................................................................................... 405
Descripción de los tipos y orígenes de errores .................................................................... 407
Administración de errores en los clientes ............................................................................ 408
Administración de errores en otros servicios de AWS ........................................................... 408
Administración de errores en aplicaciones de ejemplo ........................................................... 409
Tracing .................................................................................................................................. 409
Habilitación del seguimiento activo con la API de Lambda ..................................................... 412
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 412
Almacenamiento de dependencias en tiempo de ejecución en una capa .................................. 413
Seguimiento en las aplicaciones de ejemplo ........................................................................ 413
Tutorial: IDE de Eclipse ........................................................................................................... 414
Requisitos previos ........................................................................................................... 415
Creación y compilación de un proyecto .............................................................................. 415
Uso de Go ..................................................................................................................................... 417
Paquete de implementación ...................................................................................................... 417
Creación de un paquete de implementación en Windows ...................................................... 418
Controlador ............................................................................................................................ 419
Controlador de funciones de Lambda con tipos estructurados ................................................ 420
Uso del estado global ...................................................................................................... 421
Contexto ................................................................................................................................ 422
Acceso a la información del contexto de invocación ............................................................. 422
Registro ................................................................................................................................. 424
Visualización de registros en la Consola de administración de AWS ........................................ 425
Mediante AWS CLI .......................................................................................................... 425
Eliminación de registros ................................................................................................... 427
Errores .................................................................................................................................. 427
Tracing .................................................................................................................................. 427
Habilitación del seguimiento activo con la API de Lambda ..................................................... 430
Habilitación del seguimiento activo con AWS CloudFormation ................................................ 430
Variables de entorno ............................................................................................................... 431
Trabajar con C# .............................................................................................................................. 432
Paquete de implementación ...................................................................................................... 433
CLI de .NET Core ........................................................................................................... 433
AWS Toolkit for Visual Studio ........................................................................................... 436
Controlador ............................................................................................................................ 438
Control de flujos .............................................................................................................. 439
Control de tipos de datos estándar .................................................................................... 439
Signaturas del controlador ................................................................................................ 440
Serialización de las funciones de Lambda ........................................................................... 441
Restricciones del controlador de funciones de Lambda ......................................................... 442
Uso de async en funciones C# con AWS Lambda ................................................................ 442
Contexto ................................................................................................................................ 443
Registro ................................................................................................................................. 444
Visualización de registros en la Consola de administración de AWS ........................................ 445
Mediante AWS CLI .......................................................................................................... 446
Eliminación de registros ................................................................................................... 447
Errores .................................................................................................................................. 447
Tracing .................................................................................................................................. 450

ix
 AWS Lambda Guía para desarrolladores

Habilitación del seguimiento activo con la API de Lambda ..................................................... 452

Habilitación del seguimiento activo con AWS CloudFormation ................................................ 453
Trabajar con PowerShell .................................................................................................................. 454
Entorno de desarrollo .............................................................................................................. 454
Paquete de implementación ...................................................................................................... 455
Controlador ............................................................................................................................ 457
Devolución de datos ........................................................................................................ 457
Contexto ................................................................................................................................ 458
Registro ................................................................................................................................. 458
Visualización de registros en la Consola de administración de AWS ........................................ 460
Mediante AWS CLI .......................................................................................................... 460
Eliminación de registros ................................................................................................... 462
Errores .................................................................................................................................. 462
Monitorización ................................................................................................................................. 463
Consola de administración ........................................................................................................ 464
Métricas de funciones .............................................................................................................. 464
Uso de métricas de invocación ......................................................................................... 465
Uso de métricas de desempeño ........................................................................................ 466
Uso de métricas de simultaneidad ..................................................................................... 466
Registros de CloudWatch ......................................................................................................... 467
Seguridad ...................................................................................................................................... 469
Protección de los datos ............................................................................................................ 469
Cifrado en tránsito ........................................................................................................... 470
Cifrado en reposo ........................................................................................................... 470
Administración de identidades y accesos .................................................................................... 471
Público .......................................................................................................................... 471
Autenticación con identidades ........................................................................................... 471
Administración de acceso mediante políticas ....................................................................... 473
Cómo funciona AWS Lambda con IAM ............................................................................... 475
Ejemplos de políticas basadas en identidades ..................................................................... 475
Solución de problemas ..................................................................................................... 477
Validación de la conformidad .................................................................................................... 479
Resiliencia .............................................................................................................................. 479
Seguridad de la infraestructura .................................................................................................. 480
Configuración y análisis de vulnerabilidades ................................................................................ 481
Solución de problemas ..................................................................................................................... 482
Implementación ....................................................................................................................... 482
Invocación .............................................................................................................................. 484
Ejecución ............................................................................................................................... 486
Redes .................................................................................................................................... 488
Versiones ....................................................................................................................................... 489
Actualizaciones anteriores ........................................................................................................ 499
Referencia de la API ....................................................................................................................... 504
Actions .................................................................................................................................. 504
AddLayerVersionPermission .............................................................................................. 506
AddPermission ................................................................................................................ 509
CreateAlias ..................................................................................................................... 513
CreateEventSourceMapping .............................................................................................. 517
CreateFunction ............................................................................................................... 524
DeleteAlias ..................................................................................................................... 534
DeleteEventSourceMapping .............................................................................................. 536
DeleteFunction ................................................................................................................ 540
DeleteFunctionConcurrency .............................................................................................. 542
DeleteFunctionEventInvokeConfig ...................................................................................... 544
DeleteLayerVersion ......................................................................................................... 546
DeleteProvisionedConcurrencyConfig ................................................................................. 548
GetAccountSettings ......................................................................................................... 550

x
 AWS Lambda Guía para desarrolladores

GetAlias ......................................................................................................................... 552

GetEventSourceMapping .................................................................................................. 555
GetFunction .................................................................................................................... 559
GetFunctionConcurrency .................................................................................................. 563
GetFunctionConfiguration ................................................................................................. 565
GetFunctionEventInvokeConfig .......................................................................................... 571
GetLayerVersion ............................................................................................................. 574
GetLayerVersionByArn ..................................................................................................... 577
GetLayerVersionPolicy ..................................................................................................... 580
GetPolicy ....................................................................................................................... 582
GetProvisionedConcurrencyConfig ..................................................................................... 584
Invoke ........................................................................................................................... 587
InvokeAsync ................................................................................................................... 593
ListAliases ...................................................................................................................... 595
ListEventSourceMappings ................................................................................................. 598
ListFunctionEventInvokeConfigs ......................................................................................... 601
ListFunctions .................................................................................................................. 604
ListLayers ...................................................................................................................... 607
ListLayerVersions ............................................................................................................ 609
ListProvisionedConcurrencyConfigs .................................................................................... 612
ListTags ......................................................................................................................... 615
ListVersionsByFunction .................................................................................................... 617
PublishLayerVersion ........................................................................................................ 620
PublishVersion ................................................................................................................ 624
PutFunctionConcurrency ................................................................................................... 631
PutFunctionEventInvokeConfig .......................................................................................... 634
PutProvisionedConcurrencyConfig ...................................................................................... 638
RemoveLayerVersionPermission ........................................................................................ 641
RemovePermission .......................................................................................................... 643
TagResource .................................................................................................................. 645
UntagResource ............................................................................................................... 647
UpdateAlias .................................................................................................................... 649
UpdateEventSourceMapping ............................................................................................. 653
UpdateFunctionCode ....................................................................................................... 659
UpdateFunctionConfiguration ............................................................................................. 667
UpdateFunctionEventInvokeConfig ..................................................................................... 676
Data Types ............................................................................................................................ 679
AccountLimit ................................................................................................................... 681
AccountUsage ................................................................................................................ 682
AliasConfiguration ............................................................................................................ 683
AliasRoutingConfiguration ................................................................................................. 685
Concurrency ................................................................................................................... 686
DeadLetterConfig ............................................................................................................ 687
DestinationConfig ............................................................................................................ 688
Environment ................................................................................................................... 689
EnvironmentError ............................................................................................................ 690
EnvironmentResponse ..................................................................................................... 691
EventSourceMappingConfiguration ..................................................................................... 692
FileSystemConfig ............................................................................................................ 695
FunctionCode ................................................................................................................. 696
FunctionCodeLocation ...................................................................................................... 697
FunctionConfiguration ...................................................................................................... 698
FunctionEventInvokeConfig ............................................................................................... 703
Layer ............................................................................................................................. 705
LayersListItem ................................................................................................................ 706
LayerVersionContentInput ................................................................................................. 707
LayerVersionContentOutput .............................................................................................. 708

xi
 AWS Lambda Guía para desarrolladores

LayerVersionsListItem ...................................................................................................... 709

OnFailure ....................................................................................................................... 711
OnSuccess ..................................................................................................................... 712
ProvisionedConcurrencyConfigListItem ............................................................................... 713
TracingConfig ................................................................................................................. 715
TracingConfigResponse ................................................................................................... 716
VpcConfig ...................................................................................................................... 717
VpcConfigResponse ........................................................................................................ 718
Errores de los certificados cuando se utiliza un SDK .................................................................... 718
AWS glossary ................................................................................................................................. 720

xii
 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. 130).

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. 144).

¿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. 144) 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 Utilización de AWS
Lambda con otros servicios (p. 163).

2
 AWS Lambda Guía para desarrolladores
Crear 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 aws.amazon.com 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. 7) para
lenguajes no compilados que permite modificar y probar el código con rapidez. La AWS CLI (p. 13)
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 Lambda con la consola (p. 3)
• Creación de funciones mediante el editor de la consola de AWS Lambda (p. 7)
• Uso de AWS Lambda con AWS Command Line Interface (p. 13)
• Conceptos de AWS Lambda (p. 18)
• Características de AWS Lambda (p. 20)
• Herramientas para usar AWS Lambda (p. 29)
• Cuotas de AWS Lambda (p. 31)

Creación de una función 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 del diseñador

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

Lambda crea una función de Node.js 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 del diseñador

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.

Invocar 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
Invocar 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. En las pestañas situadas cerca de la parte superior de la página, 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
Eliminar recursos

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

Eliminar recursos
Si ha terminado de trabajar con la función de ejemplo, elimínela. También puede eliminar el rol de
ejecución creado por la consola y el grupo de registro que almacena los registros de la función.

Para eliminar una función de Lambda

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

2. Elija una función.
3. Elija Actions (Acciones) y, a continuación, elija Delete function (Eliminar función).
4. Elija Eliminar.

Para eliminar el grupo de registros

1. Abra la Log groups page (Página del grupo de registros) de la consola de Amazon CloudWatch.
2. Elija el grupo de registros de la función (/aws/lambda/my-function).
3. Elija Actions (Acciones) y, a continuación, elija Delete log group (Eliminar grupo de registro).
4. Elija Yes, Delete (Sí, eliminar).

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

Para eliminar el rol de ejecución

1. Abra la página de Roles de la consola de AWS Identity and Access Management.

2. Elija el rol de la función (my-function-role-31exxmpl
3. Elija Delete role (Eliminar rol).
4. Elija Sí, eliminar.

Puede automatizar la creación y limpieza de funciones, roles y grupos de registro con AWS
CloudFormation y la AWS CLI. Para obtener información sobre aplicaciones de ejemplo totalmente
funcionales, consulte Aplicaciones de muestra de Lambda (p. 315).

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 comandos del 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.

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

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.

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

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.
• 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.

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

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.

9
 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.

10
 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.

11
 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.

12
 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.

• Cambios de la configuración de proyecto que puede realizar

• Cambios de la configuración de usuario que puede realizar

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. 33) 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.

13
 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 file://trust-

policy.json
{
"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": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
}

El archivo trust-policy.json 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 lambda.amazonaws.com permiso para llamar a la acción AssumeRole de AWS Security Token
Service.

Example trust-policy.json

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"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":
"lambda.amazonaws.com"}, "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.

14
 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 index.js

exports.handler = async function(event, context) {

console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
console.log("EVENT\n" + JSON.stringify(event, null, 2))
return context.logStreamName
}

Para crear la función

1. Copie el código de muestra en un archivo con el nombre index.js.

2. Crear un paquete de implementación.

$ zip function.zip index.js

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://function.zip --handler index.handler --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": "index.handler",
"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
START RequestId: 57f231fb-1730-4395-85cb-4f71bd2b87b8 Version: $LATEST

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

"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 get-logs.sh

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.

$ ./get-logs.sh
{
"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",

16
 AWS Lambda Guía para desarrolladores
Listado de las funciones Lambda de su cuenta

"ingestionTime": 1559763018353
}
],
"nextForwardToken": "f/34783877304859518393868359594929986069206639495374241795",
"nextBackwardToken": "b/34783877303811383369537420289090800615709599058929582080"
}

Listado de las funciones 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": "index.handler",
...
},
{
"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": "index.handler",
...
},
...
],
"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=",
"Version": "$LATEST",
"TracingConfig": {
"Mode": "PassThrough"

17
 AWS Lambda Guía para desarrolladores
Eliminar recursos

},
"RevisionId": "88ebe1e1-bfdf-4dc3-84de-3017268fa1ff",
...
},
"Code": {
"RepositoryType": "S3",
"Location": "https://awslambda-us-east-2-tasks.s3.us-east-2.amazonaws.com/
snapshots/123456789012/my-function-4203078a-b7c9-4f35-..."
}
}

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

Eliminar recursos
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. 18)
• Qualifier (p. 18)
• Tiempo de ejecución (p. 19)
• Evento (p. 19)
• Simultaneidad (p. 19)
• Trigger (p. 20)

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. 53).

Qualifier
Al invocar o ver una función, puede incluir un calificador para especificar una versión o alias. Una versión
es una instantánea inmutable del código y la configuración de una función que tiene un calificador
numérico. Por ejemplo, my-function:1. Un alias dirige a una versión que se puede actualizar para
asignar a una versión diferente o dividir el tráfico entre dos versiones. Por ejemplo, my-function:BLUE.

18
 AWS Lambda Guía para desarrolladores
Tiempo de ejecución

Puede usar versiones y alias al mismo tiempo para proporcionar una interfaz estable para que los clientes
invoquen su función.

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

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
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. 130).

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 Utilización de AWS
Lambda con otros servicios (p. 163).

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 cuotas 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

19
 AWS Lambda Guía para desarrolladores
Trigger

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

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
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. 99) y Utilización
de AWS Lambda con otros servicios (p. 163).

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. 20)
• Paquete de implementación (p. 22)
• Capas (p. 22)
• Escalado (p. 22)
• Controles de simultaneidad (p. 23)
• Invocación asincrónica (p. 25)
• Mapeos de origen de eventos (p. 26)
• Destinos (p. 27)
• Proyectos de funciones (p. 28)
• Plantillas de aplicaciones (p. 29)

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. 311), el tiempo de ejecución registra
subsegmentos separados para la inicialización y la ejecución.

20
 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 Node.js (p. 332)

• Creación de funciones de Lambda con Python (p. 349)
• Creación de funciones de Lambda con Ruby (p. 367)
• Creación de funciones de Lambda con Java (p. 383)
• Creación de funciones de Lambda con Go (p. 417)
• Creación de funciones Lambda con C# (p. 432)
• Creación de funciones de Lambda con PowerShell (p. 454)

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

21
 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 de AWS Lambda en Node.js (p. 336)

• Paquete de implementación de AWS Lambda en Python (p. 352)
• Paquete de implementación de AWS Lambda en Ruby (p. 370)
• Paquete de implementación de AWS Lambda en Java (p. 386)
• Paquete de implementación de AWS Lambda en Go (p. 417)
• AWS Lambda Paquete de implementación en C# (p. 433)
• Paquete de implementación de AWS Lambda en PowerShell (p. 455)

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. 76).

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.

22
 AWS Lambda Guía para desarrolladores
Controles de simultaneidad

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

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.

23
 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.

24
 AWS Lambda Guía para desarrolladores
Invocación asincrónica

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

Invocación asincrónica
Al invocar una función, puede optar por invocarla de forma síncrona o asíncrona. Con invocación
síncrona (p. 100), 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.

25
 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. 27).

Para obtener más información, consulte Invocación asincrónica (p. 101).

Mapeos de origen de eventos

Para procesar elementos de una transmisión o una cola, puede crear un mapeo de origen de
eventos (p. 109). 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.

26
 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. 27).

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

Destinos
Un destino es un recurso de AWS que recibe registros de invocación para una función. Para invocación
asíncrona (p. 25), 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.

27
 AWS Lambda Guía para desarrolladores
Proyectos de funciones

Para los mapeos de origen de eventos (p. 26) 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. 104) y
las secciones de control de errores de Uso de AWS Lambda con Amazon DynamoDB (p. 216) y Uso de
AWS Lambda con Amazon Kinesis (p. 250).

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 Node.js y Python.

28
 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. 147).

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. 29)
• Modelo de aplicación sin servidor de AWS (p. 29)
• CLI de SAM (p. 30)
• Herramientas para crear código (p. 30)

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.

29
 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. 130). 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

Node.js • Consola de AWS Lambda

• Visual Studio, con el complemento del IDE (consulte Soporte de
AWS Lambda en 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 Soporte de

AWS Lambda en 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

30
 AWS Lambda Guía para desarrolladores
Cuotas

Lenguaje Herramientas y opciones para crear código

PowerShell • Su propio entorno de desarrollo

• PowerShell Core 6.0 (consulte Installing PowerShell Core)
• SDK de .NET Core 3.1 (consulte Descargas de .NET)
• Módulo AWSLambdaPSCore (consulte Galería de Powershell)

Cuotas de AWS Lambda

AWS Lambda establece cuotas para la cantidad de recursos informáticos y de almacenamiento que
puede usar para ejecutar y almacenar funciones. Las siguientes cuotas se aplican por región y se pueden
aumentar. Para solicitar un aumento, utilice la consola del Centro de soporte.

Recurso Cuota predeterminada

Ejecuciones simultáneas 1,000

Almacenamiento de funciones y capas 75 GB

Interfaces de red elástica por VPC (p. 81) 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. 114).

Las siguientes cuotas se aplican a la configuración, implementación y ejecución de funciones. No es

posible cambiarlos.

Recurso Cuota

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

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

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

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

Capas de funciones (p. 76) 5 capas

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

región (p. 114))

Frecuencia de invocación por región (solicitudes por segundo) Cuota de ejecuciones simultáneas
10 veces mayor (síncrona (p. 100) –
todos los orígenes)

Cuota de ejecuciones simultáneas

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

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

servicios de AWS (p. 163))

31
 AWS Lambda Guía para desarrolladores
Cuotas

Recurso Cuota

Frecuencia de invocación por versión de función o alias 10 x simultaneidad

(solicitudes por segundo) aprovisionada (p. 62) asignada

Esta cuota solo se aplica a funciones

que utilizan la simultaneidad
aprovisionada.

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

256 KB (asincrónica)

Tamaño del paquete de implementación (p. 22) 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

Las cuotas 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 Cuotas de servicio de AWS y Utilización de AWS Lambda con otros
servicios (p. 163).

32
 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. 33), 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. 311), 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. 109) 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. 81).

Utilice las políticas basadas en recursos (p. 37) 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. 42) 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. 47).

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. 33)
• Uso de políticas basadas en recursos para AWS Lambda (p. 37)
• Políticas de IAM basadas en identidad para AWS Lambda (p. 42)
• Recursos y condiciones para acciones de Lambda (p. 47)
• Uso de límites de permisos para aplicaciones de AWS Lambda (p. 50)

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

33
 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.

34
 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 file://trust-

policy.json
{
"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": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
}
}

El archivo trust-policy.json 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 lambda.amazonaws.com permiso para llamar a la acción AssumeRole de AWS Security Token
Service.

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

Example trust-policy.json

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"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":
"lambda.amazonaws.com"}, "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. 109) 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:

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

Servicios cuyos eventos lee Lambda

• Amazon Kinesis (p. 250)

• Amazon DynamoDB (p. 216)
• Amazon Simple Queue Service (p. 296)

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. 39) 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. 39).

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.

37
 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. 509) y AddLayerVersionPermission (p. 506). 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. 42).

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

38
 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. 163), 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 sns.amazonaws.com --output text
{"Sid":"sns","Effect":"Allow","Principal":
{"Service":"sns.amazonaws.com"},"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 sns.amazonaws.com --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 s3.amazonaws.com --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 \
--principal 210987654321 --output text

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

{"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. 42) 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. 72) 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. 48). 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. 587)

• GetFunction (p. 559)
• GetFunctionConfiguration (p. 565)
• UpdateFunctionCode (p. 659)
• DeleteFunction (p. 540)
• PublishVersion (p. 624)
• ListVersionsByFunction (p. 617)
• CreateAlias (p. 513)
• GetAlias (p. 552)
• ListAliases (p. 595)
• UpdateAlias (p. 649)
• DeleteAlias (p. 534)
• GetPolicy (p. 582)
• PutFunctionConcurrency (p. 631)
• DeleteFunctionConcurrency (p. 542)
• ListTags (p. 615)
• TagResource (p. 645)
• UntagResource (p. 647)

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

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

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":"s3.amazonaws.com"},"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

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.

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

$ 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 de IAM basadas en identidad 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. 42)
• Desarrollo y uso de capas (p. 45)
• Roles entre cuentas (p. 46)
• Claves de condición para la configuración de la VPC (p. 46)

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",
"Statement": [

42
 AWS Lambda Guía para desarrolladores
Desarrollo de funciones

{
"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:GetRolePolicy",
"iam:PassRole",
"iam:SimulatePrincipalPolicy"
],
"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-*"

43
 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. 47) 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. 37) 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:GetRolePolicy",

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

"iam:PassRole",
"iam:SimulatePrincipalPolicy"
],
"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-*"
},
{

45
 AWS Lambda Guía para desarrolladores
Roles entre cuentas

"Sid": "ManageLayerVersions",
"Effect": "Allow",
"Action": [
"lambda:GetLayerVersion",
"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. 37) en su lugar.

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

Claves de condición para la configuración de la VPC

Puede utilizar claves de condición para la configuración de la VPC para proporcionar controles de permisos
adicionales para sus funciones Lambda. Por ejemplo, puede exigir que todas las funciones Lambda de

46
 AWS Lambda Guía para desarrolladores
Recursos y condiciones

la organización estén conectadas a una VPC. También puede especificar las subredes y los grupos de
seguridad que las funciones pueden utilizar o a los que se les deniega el uso.

Para obtener más información, consulte the section called “Uso de claves de condición de IAM para la
configuración de la VPC” (p. 83).

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
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 recurso 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 EE.UU. Oeste (Oregón).

Example invocar 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. 587)). 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,

47
 AWS Lambda Guía para desarrolladores
Funciones

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 administrar permisos de una política de función

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ManageFunctionPolicy",
"Effect": "Allow",
"Action": [
"lambda:AddPermission",
"lambda:RemovePermission"
],
"Resource": "arn:aws:lambda:us-west-2:123456789012:function:test:*",
"Condition": {
"StringEquals": {
"lambda:Principal": "sns.amazonaws.com"
}
}
}
]
}

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 condiciones, recursos y acciones en la Guía del usuario de IAM.

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

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. 509) Función lambda:Principal

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

Alias de función

Invoke (p. 587) Función Ninguno

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

Acción Recurso Condición

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

Alias de función

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

UpdateFunctionConfiguration (p. 667) lambda:VpcIds

lambda:SubnetIds

lambda:SecurityGroupIds

CreateAlias (p. 513) Función Ninguno

DeleteAlias (p. 534)

DeleteFunction (p. 540)

DeleteFunctionConcurrency (p. 542)

GetAlias (p. 552)

GetFunction (p. 559)

GetFunctionConfiguration (p. 565)

GetPolicy (p. 582)

ListAliases (p. 595)

ListVersionsByFunction (p. 617)

PublishVersion (p. 624)

PutFunctionConcurrency (p. 631)

UpdateAlias (p. 649)

UpdateFunctionCode (p. 659)

GetAccountSettings (p. 550) * Ninguno

ListFunctions (p. 604)

ListTags (p. 615)

TagResource (p. 645)

UntagResource (p. 647)

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.

49
 AWS Lambda Guía para desarrolladores
Capas

Mapeos de origen de eventos

Acción Recurso Condición

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

UpdateEventSourceMapping (p. 653)

CreateEventSourceMapping (p. 517) * lambda:FunctionArn

GetEventSourceMapping (p. 555) * Ninguno

ListEventSourceMappings (p. 598)

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
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. 506) Versión de la capa Ninguno

RemoveLayerVersionPermission (p. 641)

GetLayerVersion (p. 574)

GetLayerVersionPolicy (p. 580)

DeleteLayerVersion (p. 546)

PublishLayerVersion (p. 620) Capa Ninguno

ListLayers (p. 607) * Ninguno

ListLayerVersions (p. 609)

Uso de límites de permisos para aplicaciones de

AWS Lambda
Al crear una aplicación (p. 147) 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. 33) 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:

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

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

{
"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.

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

• 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. 147).

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

52
 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. 54) 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. 56) 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. 70) son recursos secundarios que puede crear para administrar la
implementación e invocación de funciones. Publique versiones (p. 70) de su función para almacenar
su código y configuración como recurso independiente que no puede cambiarse y cree un alias (p. 72)
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. 76) 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. 81). 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. 87) 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. 54)
• Uso de variables de entorno de AWS Lambda (p. 56)
• Administración de la simultaneidad para una función de Lambda (p. 62)
• Versiones de funciones de AWS Lambda (p. 70)
• Alias de la función AWS Lambda (p. 72)
• Capas de AWS Lambda (p. 76)
• Configuración de una función de Lambda para obtener acceso a los recursos de una VPC (p. 81)
• Configuración del acceso a la base de datos para una función Lambda (p. 87)
• Configuración del acceso al sistema de archivos para las funciones Lambda (p. 91)
• Etiquetado de funciones de Lambda (p. 95)

53
 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. 109) 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 Utilización de AWS Lambda con otros
servicios (p. 163).
• Capas: elija el nodo Layers (Capas) para añadir capas (p. 76) 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. 101)
o mediante un mapeo de origen de eventos (p. 109) que se lee desde un flujo.

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

Configuración de 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. 7) integrado. Para añadir bibliotecas, o para los lenguajes no
admitidos por el editor, cargue un paquete de implementación (p. 22). 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.

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

• Runtime (Tiempo de ejecución): El tiempo de ejecución de Lambda (p. 130) que ejecuta la función.
• Handler (Controlador): El método que ejecuta el tiempo de ejecución cuando se invoca la función, como
index.handler. 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. 56) 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. 95) 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. 33) 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. 31), 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. 81).
• Database proxies (Proxies de base de datos): cree un proxy de base de datos (p. 87) 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. 311).
• Concurrency (Simultaneidad): Reserve simultaneidad para una función (p. 62) 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. 101) 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. 107) 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. 72) para propagar los cambios de configuración de manera controlada.

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

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

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

55
 AWS Lambda Guía para desarrolladores
Variables de entorno

• AddPermission (p. 509): modifica la política basada en recursos (p. 37) de una función, una versión o
un alias.
• PutFunctionConcurrency (p. 631): configura la simultaneidad reservada de una función.
• PublishVersion (p. 624): crea una versión inmutable con el código y la configuración actuales.
• CreateAlias (p. 513): 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. 160).

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. 54).

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. 58).
• 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.

56
 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.

Node.js

let region = process.env.AWS_REGION

Python

import os
region = os.environ['AWS_REGION']

Ruby

region = ENV["AWS_REGION"]

Java

String region = System.getenv("AWS_REGION");

Go

var region = os.Getenv("AWS_REGION")

C#

string region = Environment.GetEnvironmentVariable("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. 59), 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. 58)
• Proteger variables de entorno (p. 59)

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

• Configuración de variables de entorno con la API de Lambda (p. 60)

• Código de muestra y plantillas (p. 61)

Variables de entorno de tiempo de ejecución

Los tiempos de ejecución (p. 130) 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. 130), 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. 33) de la función.
• AWS_LAMBDA_RUNTIME_API: (Tiempo de ejecución personalizado (p. 134)) El host y el puerto de la
API de tiempo de ejecución (p. 136).
• 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: (Node.js (p. 332)) La ruta de la biblioteca Node.js (/opt/nodejs/node12/
node_modules/:/opt/nodejs/node_modules:$LAMBDA_RUNTIME_DIR/node_modules).
• PYTHONPATH: (Python 2.7, 3.6, 3.8 (p. 349)) La ruta de la biblioteca de Python
($LAMBDA_RUNTIME_DIR).
• GEM_PATH: (Ruby (p. 367)) La ruta de la biblioteca Ruby ($LAMBDA_TASK_ROOT/vendor/bundle/
ruby/2.5.0:/opt/ruby/gems/2.5.0).
• _X_AMZN_TRACE_ID: el encabezado de rastreo X-Ray (p. 311).
• AWS_XRAY_CONTEXT_MISSING: para el seguimiento de X-Ray, Lambda establece esto en LOG_ERROR
para evitar arrojar errores de tiempo de ejecución desde el SDK de X-Ray.
• AWS_XRAY_DAEMON_ADDRESS: para el seguimiento de X-Ray, la dirección IP y el puerto del demonio de
X-Ray.

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

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.

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. 42). 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"

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

],
"Resource": "arn:aws:kms:us-east-2:123456789012:key/3be10e2d-xmpl-4be4-
bc9d-0405a71945cc"
}
]
}

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

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. Elija Save (Guardar).

Note

Cuando utiliza los ayudantes de cifrado de la consola, la función necesita permiso para llamar a la
operación de la API kms:Decrypt en su rol de ejecución (p. 33).

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.

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

• UpdateFunctionConfiguration (p. 667)

• GetFunctionConfiguration (p. 565)
• CreateFunction (p. 524)

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

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

--environment "Variables={BUCKET=my-bucket,KEY=file.txt}"

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": "file.txt"
}
},
"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 muestra

• En blanco (p. 316): 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.

61
 AWS Lambda Guía para desarrolladores
Simultaneidad

Administración de la simultaneidad para una

función de 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
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 una cuota (p. 31) 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. 62). 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. 130) 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. 114), 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. 64). 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. 67) para registrar un objetivo y crear una política de escalado.

La simultaneidad aprovisionada cuenta en las cuotas regionales y de simultaneidad reservadas 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. 62)
• Configuración de simultaneidad aprovisionada (p. 64)
• Configuración de simultaneidad con la API de Lambda (p. 67)

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.

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

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
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.

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

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
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.

64
 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. 114), 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 cuotas de escalado a todas las solicitudes.

65
 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. 20) 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. 311) 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.

66
 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 funciones de AWS Lambda (p. 464).

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. 631)

• GetFunctionConcurrency
• DeleteFunctionConcurrency (p. 542)
• PutProvisionedConcurrencyConfig
• GetProvisionedConcurrencyConfig
• ListProvisionedConcurrencyConfigs
• DeleteProvisionedConcurrencyConfig
• GetAccountSettings (p. 550)
• (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:

67
 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

68
 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 consultar las cuotas de simultaneidad de su cuenta en una región, utilice get-account-settings.

$ aws lambda get-account-settings

{

69
 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. 54).

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.

70
 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. 624).

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": "function.handler",
"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:

71
 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. 37) 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 la función AWS Lambda (p. 72).

Alias de la función 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).

72
 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

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

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

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

• CreateAlias (p. 513)

• UpdateAlias (p. 649)
• DeleteAlias (p. 534)

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.

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

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.

Políticas de recursos
Cuando se utiliza una política basada en recursos (p. 37) 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 s3.amazonaws.com --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. 70).
4. En el menú Actions (Acciones), elija Create alias (Crear alias).

74
 AWS Lambda Guía para desarrolladores
Configuración de direccionamiento de 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
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.

Configurar el direccionamiento del 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. 513)

• UpdateAlias (p. 649)

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:

75
 AWS Lambda Guía para desarrolladores
Capas

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
funciones de AWS Lambda (p. 464).
• 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.

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. 134) 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 Node.js, Python y Ruby, puede desarrollar el código de su función
en la consola de Lambda (p. 7) 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 Cuotas de AWS Lambda (p. 31).

Puede crear capas o utilizar capas publicadas por AWS y otros clientes de AWS. Las capas admiten
políticas basadas en recursos (p. 80) 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. 79) 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. 76)
• Administración de capas (p. 77)
• Inclusión de dependencias de biblioteca en una capa (p. 79)
• Permisos de capa (p. 80)
• AWS CloudFormation y AWS SAM (p. 80)
• Aplicaciones de muestra (p. 81)

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.

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

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",
"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. 130) 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=layer.zip --compatible-
runtimes python3.6 python3.7
{
"Content": {
"Location": "https://awslambda-us-east-2-layers.s3.us-east-2.amazonaws.com/
snapshots/123456789012/my-layer-4aaa2fbb-ff77-4b0a-ad92-5b78a716a96a?
versionId=27iWyA73cCAYqyH...",
"CodeSha256": "tv9jJO+rPbXUUXuRKi7CwHzKtLDkDRJLB3cC3Z/ouXo=",
"CodeSize": 169
},

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

"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"
]
}

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. 80) 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": "https://awslambda-us-east-2-layers.s3.us-east-2.amazonaws.com/
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",

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

"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

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
o modifique esa variable de ruta para su idioma.

• Node.js – nodejs/node_modules, nodejs/node8/node_modules (NODE_PATH)

Example SDK de AWS X-Ray para Node.js

xray-sdk.zip
# nodejs/node_modules/aws-xray-sdk

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

Example Pillow

pillow.zip
# python/PIL
# python/Pillow-5.3.0.dist-info

• Ruby: ruby/gems/2.5.0 (GEM_PATH), ruby/lib (RUBYLIB)

Example JSON

json.zip
# ruby/gems/2.5.0/
| build_info
| cache
| doc
| extensions
| gems
| # json-2.1.0
# specifications
# json-2.1.0.gemspec

• Java – java/lib (classpath)

Example Jackson

jackson.zip
# java/lib/jackson-core-2.2.3.jar

79
 AWS Lambda Guía para desarrolladores
Permisos de capa

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

Example JQ

jq.zip
# bin/jq

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. 58).

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. 42) o desde la política basada en
recursos (p. 37) 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. 41).

AWS CloudFormation y AWS SAM

Utilice Modelo de aplicación sin servidor de AWS (AWS SAM) en sus plantillas de AWS
CloudFormation para automatizar la creación el mapeo de capas en su aplicación. El tipo de recurso
AWS::Serverless::LayerVersion crea una versión de capa a la que puede hacer referencia desde la
configuración de la función.

Example blank-nodejs/template.yml: recursos sin servidor

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:
Handler: index.handler
Runtime: nodejs12.x
CodeUri: function/.
Description: Call the AWS Lambda API
Timeout: 10
# Function's execution role

80
 AWS Lambda Guía para desarrolladores
Aplicaciones de muestra

Policies:
- AWSLambdaBasicExecutionRole
- AWSLambdaReadOnlyAccess
- AWSXrayWriteOnlyAccess
Tracing: Active
Layers:
- !Ref libs
libs:
Type: AWS::Serverless::LayerVersion
Properties:
LayerName: blank-nodejs-lib
Description: Dependencies for the blank sample app.
ContentUri: lib/.
CompatibleRuntimes:
- nodejs12.x

Cuando actualiza sus dependencias e realiza la implementación, AWS SAM crea una nueva versión de la
capa y actualiza el mapeo. Si implementa cambios en el código sin modificar sus dependencias, AWS SAM
omite la actualización de capa, ahorrando tiempo de carga.

Aplicaciones de muestra
El repositorio de GitHub para esta guía proporciona aplicaciones de ejemplo (p. 315) que demuestran el
uso de capas para la administración de dependencias.

• Node.js: blank-nodejs
• Python: blank-python
• Ruby: blank-ruby
• Java: blank-java

Para obtener más información acerca de la aplicación de ejemplo en blanco, consulte Aplicación de
ejemplo de función en blanco para AWS Lambda (p. 316).

Configuración de una función de Lambda para

obtener acceso a los recursos de una VPC
Puede configurar una función Lambda para conectarse a subredes privadas en una nube virtual privada
(VPC) de su cuenta de AWS. 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 página Functions (Funciones) en la consola de Lambda.

2. Elija una función.
3. En VPC, elija Edit (Editar).
4. Para la VPC connection (Conexión de VPC), 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 su función

necesita acceso a Internet, utilice traducción de direcciones de red (NAT) (p. 87). La

81
 AWS Lambda Guía para desarrolladores
Permisos de usuario y rol de ejecución

conexión de 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
alrededor de un minuto.

Mientras Lambda crea una interfaz de red, no se pueden realizar operaciones adicionales que se dirijan
a la función, como creación de versiones (p. 70) o actualización del código de la función. Para nuevas
funciones, no se puede invocar la función hasta que su estado cambie de Pending a Active. Para las
funciones existentes, todavía puede invocar la versión anterior mientras la actualización está en curso.
Para obtener más información acerca de los estados de función, consulte Monitorización del estado de una
función con la API de Lambda (p. 113).

Varias funciones conectadas a las mismas subredes comparten interfaces de red. Conectar funciones
adicionales a una subred que tiene una interfaz de red administrada por Lambda existente es mucho
más rápido que hacer que Lambda cree interfaces de red adicionales. Sin embargo, si tiene muchas
funciones o funciones con un alto uso de red, es posible que Lambda pueda todavía crear interfaces de
red adicionales.

Si las funciones no están activas durante un largo periodo de tiempo, Lambda reclama las interfaces de red
y las funciones pasan a ser Idle. Para reactivar una función inactiva, invóquela. Esta invocación produce
un error y la función vuelve a encontrarse en un estado Pending hasta que esté disponible una interfaz de
red.

Las funciones Lambda no pueden conectarse directamente a una VPC con tenencia de instancias
dedicada. 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. 269)
• Tutorial: Configuración de una función de Lambda para obtener acceso a Amazon ElastiCache en una
Amazon VPC (p. 241)

Secciones
• Permisos de usuario y rol de ejecución (p. 82)
• Configuración del acceso a la VPC con la API de Lambda (p. 83)
• Uso de claves de condición de IAM para la configuración de la VPC (p. 83)
• Acceso a Internet y a los servicios para funciones conectadas a la VPC (p. 87)
• Ejemplos de configuraciones de VPC (p. 87)

Permisos de usuario y rol de ejecución

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 (p. 33) de la función debe tener los siguientes permisos:

Permisos de rol de ejecución

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

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

Estos permisos están incluidos en la política administrada de AWS

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 AWS Identity and Access
Management (IAM) necesita los siguientes permisos:

Permisos de usuario

• ec2:DescribeSecurityGroups
• ec2:DescribeSubnets
• ec2:DescribeVpcs

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

Lambda
Para conectar una función Lambda a una VPC, puede utilizar las siguientes operaciones de la API:

• CreateFunction (p. 524)

• UpdateFunctionConfiguration (p. 667)

Para crear una función y conectarla a una VPC mediante la AWS Command Line Interface (AWS CLI),
puede utilizar el comando create-function con la opción vpc-config. 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 index.js --zip-file fileb://function.zip \
--role arn:aws:iam::123456789012:role/lambda-role \
--vpc-config
SubnetIds=subnet-071f712345678e7c8,subnet-07fd123456788a036,SecurityGroupIds=sg-085912345678492fb

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

$ 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=[]

Uso de claves de condición de IAM para la

configuración de la VPC
Puede utilizar claves de condición específicas de Lambda para la configuración de la VPC para
proporcionar controles de permisos adicionales para sus funciones Lambda. Por ejemplo, puede requerir
que todas las funciones de la organización estén conectadas a una VPC. También puede especificar las
subredes y los grupos de seguridad que los usuarios de la función pueden y no pueden utilizar.

83
 AWS Lambda Guía para desarrolladores
Uso de claves de condición de IAM
para la configuración de la VPC

Lambda admite las siguientes claves de condición en las políticas de IAM:

• lambda:VpcIds: permiten o deniegan una o varias VPC.

• lambda:SubnetIds: permiten o deniegan una o varias subredes.
• lambda:SecurityGroupIds: permiten o deniegan uno o varios grupos de seguridad.

Las operaciones de la API de Lambda CreateFunction (p. 524) y UpdateFunctionConfiguration (p. 667)
admiten estas claves de condición. Para obtener información sobre el uso de claves de condición en las
políticas de IAM, consulte Elementos de la política de JSON de IAM: Condición en la Guía del usuario de
IAM.
Tip
Si su función ya incluye una configuración de VPC de una solicitud de la API anterior, puede
enviar una solicitud UpdateFunctionConfiguration sin la configuración de la VPC.

Políticas de ejemplo con claves de condición para la

configuración de la VPC
En los ejemplos siguientes se muestra cómo utilizar claves de condición para la configuración de la VPC.
Después de crear una instrucción de política con las restricciones deseadas, agregue la instrucción de
política para el usuario o rol de IAM de destino.

Asegúrese de que los usuarios implementen solo funciones conectadas a la VPC

Para asegurarse de que todos los usuarios implementen solo funciones conectadas a la VPC, puede
denegar operaciones de creación y actualización de funciones que no incluyan un ID de VPC válido.

Tenga en cuenta que el ID de VPC no es un parámetro de entrada para la solicitud CreateFunction o

UpdateFunctionConfiguration. Lambda recupera el valor ID de la VPC en función de los parámetros
de subred y grupo de seguridad.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EnforceVPCFunction",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"Null": {
"lambda:VpcIds": "true"
}
}
}
]
}

Denegar a los usuarios el acceso a VPC, subredes o grupos de seguridad

específicos
Para denegar a los usuarios el acceso a VPC específicas, utilice StringEquals para comprobar el valor
de la condición lambda:VpcIds. En el ejemplo siguiente se deniega a los usuarios el acceso a vpc-1 y
vpc-2.

84
 AWS Lambda Guía para desarrolladores
Uso de claves de condición de IAM
para la configuración de la VPC

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": ["vpc-1", "vpc-2"]
}
}
}

Para denegar a los usuarios el acceso a subredes específicas, utilice StringEquals para comprobar el
valor de la condición lambda:SubnetIds. En el ejemplo siguiente se deniega a los usuarios el acceso a
subnet-1 y subnet-2.

{
"Sid": "EnforceOutOfSubnet",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}

Para denegar a los usuarios el acceso a grupos de seguridad específicos, utilice StringEquals para
comprobar el valor de la condición lambda:SecurityGroupIds. En el ejemplo siguiente se deniega a
los usuarios el acceso a sg-1 y sg-2.

{
"Sid": "EnforceOutOfSecurityGroups",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}

85
 AWS Lambda Guía para desarrolladores
Uso de claves de condición de IAM
para la configuración de la VPC

Permitir a los usuarios crear y actualizar funciones con configuraciones

específicas de VPC
Para permitir a los usuarios acceder a VPC específicas, utilice StringEquals para comprobar el valor
de la condición lambda:VpcIds. En el siguiente ejemplo se permite a los usuarios acceder a vpc-1 y
vpc-2.

{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EnforceStayInSpecificVpc",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"StringEquals": {
"lambda:VpcIds": ["vpc-1", "vpc-2"]
}
}
}

Para permitir a los usuarios acceder a subredes específicas, utilice StringEquals para comprobar el
valor de la condición lambda:SubnetIds. En el siguiente ejemplo se permite a los usuarios acceder a
subnet-1 y subnet-2.

{
"Sid": "EnforceStayInSpecificSubnets",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SubnetIds": ["subnet-1", "subnet-2"]
}
}
}

Para permitir a los usuarios acceder a grupos de seguridad específicos, utilice StringEquals para
comprobar el valor de la condición lambda:SecurityGroupIds. En el siguiente ejemplo se permite a los
usuarios acceder a sg-1 y sg-2.

{
"Sid": "EnforceStayInSpecificSecurityGroup",
"Action": [
"lambda:CreateFunction",
"lambda:UpdateFunctionConfiguration"
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]

86
 AWS Lambda Guía para desarrolladores
Acceso a Internet y a los servicios
para funciones conectadas a la VPC

}
}
}
]
}

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 servicios e
Internet de AWS. Lambda posee esta VPC, que no está conectada a la VPC predeterminada de la cuenta.
Al conectar una función a una VPC de su cuenta, la función no puede acceder a Internet a no ser que su
VPC proporcione acceso.
Note

Varios servicios de AWS ofrecen puntos de enlace de la VPC. Puede utilizar los puntos de enlace
de la 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, enrute 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 Cómo conceder acceso a Internet
a una función Lambda en una VPC.

Ejemplos de configuraciones de VPC

Puede utilizar las siguientes plantillas de AWS CloudFormation de ejemplo para crear configuraciones de
VPC que se usarán con funciones Lambda. Hay dos plantillas disponibles en el repositorio de GitHub de
esta guía:

• vpc-private.yaml: una VPC con dos subredes privadas y puntos de enlace de la VPC para Amazon
Simple Storage Service (Amazon S3) y Amazon DynamoDB. Utilice 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 los 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.
• vpc-privatepublic.yaml: 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 enruta a la gateway NAT mediante una tabla de enrutamiento.

Para crear una VPC con una plantilla, en la página Pilas de la consola de AWS CloudFormation, elija
Create stack (Crear pila) y, a continuación, siga las instrucciones del asistente de Create stack (Crear pila).

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 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. 19)
sin agotar las conexiones de base de datos.

87
 AWS Lambda Guía para desarrolladores
Uso de los permisos de la función para autenticación

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 RDS: Una instancia de base de datos o clúster de MySQL o PostgreSQL
compatible.
• 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.
• Autenticación: método de autenticación y autorización para conectarse al proxy desde el código de
función.
5. Elija Add (Añadir).

Precios

Amazon RDS cobra un precio por hora para los proxies que está determinado por el tamaño de
instancia de su base de datos. Para obtener más información, consulte Precios del proxy de RDS.

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.

Se aplican los precios de Proxy de Amazon RDS estándar. 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.

Temas
• Uso de los permisos de la función para autenticación (p. 88)
• Aplicación de muestra (p. 89)

Uso de los permisos de la función para autenticación

De forma predeterminada, puede conectarse a un proxy con el mismo nombre de usuario y contraseña
que utiliza para conectarse a la base de datos. La única diferencia en su código de función es el punto
de enlace al que se conecta el cliente de base de datos. El inconveniente de este método es que debe
exponer la contraseña a su código de función, ya sea configurándola en una variable de entorno seguro o
recuperándola de Secrets Manager.

Puede crear un proxy de base de datos que utilice las credenciales de IAM de la función para la
autenticación y autorización en lugar de una contraseña. Para utilizar los permisos de la función para
conectarse al proxy, establezca la función Authentication (Autenticación) en Execution role (Rol de
ejecución).

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

La consola Lambda agrega el permiso requerido (rds-db:connect) al rol de ejecución. A continuación,

puede utilizar el SDK de AWS para generar un token que le permita conectarse al proxy. El siguiente
ejemplo muestra cómo configurar una conexión de base de datos con la biblioteca mysql2 en Node.js.

Example dbadmin/index-iam.js: firmante de SDK de AWS

const signer = new AWS.RDS.Signer({

region: region,
hostname: host,
port: sqlport,
username: username
})

exports.handler = async (event) => {

let connectionConfig = {
host : host,
user : username,
database : database,
ssl: 'Amazon RDS',
authPlugins: { mysql_clear_password: () => () => signer.getAuthToken() }
}
var connection = mysql.createConnection(connectionConfig)
var query = event.query
var result
connection.connect()

Para obtener más información, consulte la sección sobre autenticación de bases de datos de IAM en la
Guía del usuario de Amazon RDS.

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 template-vpcrds.yml 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.

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

• 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.

90
 AWS Lambda Guía para desarrolladores
Sistema de archivos

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

Configuración del acceso al sistema de archivos

para las funciones Lambda
Puede configurar una función para montar un sistema de archivos Amazon Elastic File System (Amazon
EFS) en un directorio local. Con Amazon EFS, el código de función puede acceder y modificar los recursos
compartidos de forma segura y en alta concurrencia.

Una función se conecta a un sistema de archivos a través de la red local en una VPC. Las subredes a
las que se conecta la función pueden ser las mismas subredes que contienen puntos de montaje para el
sistema de archivos, o subredes en la misma zona de disponibilidad que pueden enrutar el tráfico NFS
(puerto 2049) al sistema de archivos.
Note
Si la función aún no está conectada a una VPC, consulte Configuración de una función de
Lambda para obtener acceso a los recursos de una VPC (p. 81).

Para configurar el acceso al sistema de archivos

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

91
 AWS Lambda Guía para desarrolladores
Configuración de un sistema de
archivos y un punto de acceso

2. Elija una función.

3. En Sistema de archivos, elija Agregar sistema de archivos.
4. Configure las siguientes propiedades:

• Sistema de archivos EFS: el punto de acceso para un sistema de archivos de la misma VPC.
• Ruta de montaje local: La ubicación en la que se monta el sistema de archivos en la función
Lambda, empezando por /mnt/.

Precios

Amazon EFS tiene cargos por almacenamiento y rendimiento, con tarifas que varían según la
clase de almacenamiento. Consulte Precios de Amazon EFS para obtener más información.
Cargos de Lambda por transferencia de datos entre VPC. Esto solo se aplica si la VPC de su
función está pegada a otra VPC con un sistema de archivos. Las tasas son las mismas que para
la transferencia de datos de Amazon EC2 entre VPC de la misma región. Consulte Precios de
Lambda para obtener más información.

Para obtener más información acerca de la integración de Lambda con Amazon EFS, consulte Uso de
Amazon EFS con Lambda (p. 245).

Secciones
• Configuración de un sistema de archivos y un punto de acceso (p. 92)
• Permisos de usuario y rol de ejecución (p. 93)
• Configurar el acceso al sistema de archivos con la API de Lambda (p. 93)
• AWS CloudFormation y AWS SAM (p. 94)
• Aplicaciones de muestra (p. 95)

Configuración de un sistema de archivos y un punto

de acceso
Cree un sistema de archivos en Amazon EFS con un destino de montaje en cada zona de disponibilidad
a la que se conecte su función. Para obtener rendimiento y resistencia, utilice al menos dos zonas de
disponibilidad. Por ejemplo, en una configuración simple, podría tener una VPC con dos subredes privadas
en zonas de disponibilidad separadas. La función se conecta a ambas subredes y un destino de montaje
está disponible en cada una. Asegúrese de que los grupos de seguridad utilizados por la función y los
destinos de montaje permiten el tráfico NFS (puerto 2049).
Note

Cuando crea un sistema de archivos, elige un modo de rendimiento que no se puede cambiar
más adelante. El modo Propósito general tiene menor latencia, y el modo E/S Max admite
un rendimiento e IOPS máximos más altos. Para obtener ayuda sobre cómo elegir, consulte
Rendimiento de Amazon EFS en la Guía del usuario de Amazon Elastic File System.

Un punto de acceso conecta cada instancia de la función con el destino de montaje correcto para la zona
de disponibilidad a la que se conecta. Para obtener el mejor rendimiento, cree un punto de acceso con
una ruta que no sea raíz y limite el número de archivos que crea en cada directorio. Los ID de usuario
y propietario son obligatorios, pero no necesitan tener un valor específico. En el siguiente ejemplo se
crea un directorio denominado my-function en el sistema de archivos y se establece el identificador de
propietario en 1001 con permisos de directorio estándar (755).

Example configuración de punto de acceso

• Nombre – files

92
 AWS Lambda Guía para desarrolladores
Permisos de usuario y rol de ejecución

• ID de usuario – 1001
• ID del grupo – 1001
• Ruta – /my-function
• Permisos – 755
• ID de usuario del propietario – 1001
• ID de usuario de grupo – 1001

Cuando una función utiliza el punto de acceso, se le da el ID de usuario 1001 y tiene acceso completo al
directorio.

Para obtener más información, consulte los siguientes temas en la Amazon Elastic File System User
Guide:

• Creación de recursos para Amazon EFS

• Trabajar con usuarios, grupos y permisos

Permisos de usuario y rol de ejecución

Lambda utiliza los permisos de su función para montar sistemas de archivos. Para conectarse a un sistema
de archivos, el rol de ejecución de la función debe tener los siguientes permisos además de los permisos
necesarios para conectarse a la VPC del sistema de archivos (p. 82):

Permisos de rol de ejecución

• elasticfilesystem:ClientMount
• elasticfilesystem:ClientWrite (no se necesita para conexiones de solo lectura)

Estos permisos se incluyen en la política administrada AmazonElasticFileSystemClientReadWriteAccess.

Cuando configura un sistema de archivos, Lambda utiliza sus permisos para verificar los destinos de
montaje. Para configurar una función para conectarse a un sistema de archivos, su usuario de IAM
necesita los siguientes permisos.

Permisos de usuario

• elasticfilesystem:DescribeMountTargets

Configurar el acceso al sistema de archivos con la API

de Lambda
Utilice las siguientes operaciones de API para conectar su función Lambda a un sistema de archivos:

• CreateFunction (p. 524)

• UpdateFunctionConfiguration (p. 667)

Para conectar una función a un sistema de archivos, utilice el comando update-function-

configuration. En el siguiente ejemplo se conecta una función denominada my-function a un
sistema de archivos con ARN de un punto de acceso.

$ ARN=arn:aws:elasticfilesystem:us-east-2:123456789012:access-point/fsap-015cxmplb72b405fd

93
 AWS Lambda Guía para desarrolladores
AWS CloudFormation y AWS SAM

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

--fs-config FileSystemArn=$ARN,LocalMountPath=/mnt/efs0

Puede obtener el ARN del punto de acceso de un sistema de archivos con el comando describe-
access-points.

$ aws efs describe-access-points

{
"AccessPoints": [
{
"ClientToken": "console-aa50c1fd-xmpl-48b5-91ce-57b27a3b1017",
"Name": "lambda-ap",
"Tags": [
{
"Key": "Name",
"Value": "lambda-ap"
}
],
"AccessPointId": "fsap-015cxmplb72b405fd",
"AccessPointArn": "arn:aws:elasticfilesystem:us-east-2:123456789012:access-
point/fsap-015cxmplb72b405fd",
"FileSystemId": "fs-aea3xmpl",
"RootDirectory": {
"Path": "/"
},
"OwnerId": "123456789012",
"LifeCycleState": "available"
}
]
}

AWS CloudFormation y AWS SAM

Puede utilizar AWS CloudFormation y Modelo de aplicación sin servidor de AWS (AWS SAM) para
automatizar la creación de aplicaciones de Lambda. Para habilitar una conexión de sistema de archivos en
un recurso AWS::Serverless::Function de AWS SAM, utilice la propiedad FileSystemConfigs.

Example template.yml: configuración del sistema de archivos

Resources:
VPC:
Type: AWS::EC2::VPC
Properties:
CidrBlock: 10.0.0.0/16
Subnet1:
Type: AWS::EC2::Subnet
Properties:
VpcId:
Ref: VPC
CidrBlock: 10.0.1.0/24
AvailabilityZone: "eu-central-1a"
EfsSecurityGroup:
Type: AWS::EC2::SecurityGroup
Properties:
VpcId:
Ref: VPC
GroupDescription: "mnt target sg"
SecurityGroupEgress:
- IpProtocol: -1
CidrIp: "0.0.0.0/0"
FileSystem:

94
 AWS Lambda Guía para desarrolladores
Aplicaciones de muestra

Type: AWS::EFS::FileSystem
Properties:
PerformanceMode: generalPurpose
MountTarget1:
Type: AWS::EFS::MountTarget
Properties:
FileSystemId:
Ref: FileSystem
SubnetId:
Ref: Subnet1
SecurityGroups:
- Ref: EfsSecurityGroup
MyFunctionWithEfs:
Type: AWS::Serverless::Function
Properties:
CodeUri: function/.
Description: Use a file system.
FileSystemConfigs:
-
Arn: !Sub
- "arn:aws:elasticfilesystem:eu-central-1:123456789101:access-point/${ap}"
- {ap: !Ref AccessPoint}
LocalMountPath: "/mnt/efs0"
DependsOn: "MountTarget1"

Debe agregar el DependsOn para asegurarse de que los destinos de montaje se crean completamente
antes de las ejecuciones de Lambda por primera vez.

Para el tipo AWS::Lambda::Function de AWS CloudFormation, el nombre de la propiedad y los

campos son los mismos. Para obtener más información, consulte Uso de AWS Lambda con AWS
CloudFormation (p. 203).

Aplicaciones de muestra
El repositorio de GitHub para esta guía incluye una aplicación de ejemplo que demuestra el uso de
Amazon EFS con una función Lambda.

• efs-nodejs: una función que utiliza un sistema de archivos de Amazon EFS en una Amazon VPC.
Este ejemplo incluye una VPC, un sistema de archivos, objetivos de montaje y un punto de acceso
configurados para su uso con Lambda.

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.

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).

95
 AWS Lambda Guía para desarrolladores
Etiquetas

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.
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.

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

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. 97)
• Requisitos de las claves y los valores de las etiquetas (p. 98)

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 index.js --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. 615) – 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:

97
 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. 559) – 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: + - = . _ : / @.

98
 AWS Lambda Guía para desarrolladores

Invocación de funciones de AWS

Lambda
Puede invocar funciones de Lambda directamente con la consola de Lambda (p. 4), la API de Lambda, el
SDK de AWS, la AWS CLI y los kits 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. 100), espere la función para procesar el evento y devolver una respuesta. Con invocación
asíncrona (p. 101), 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. 104).

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. 109). 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 Utilización de AWS Lambda con
otros servicios (p. 163).

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. 114) y Control de errores y reintentos automáticos en AWS
Lambda (p. 119).

Temas
• Invocación síncrona (p. 100)
• Invocación asincrónica (p. 101)
• Mapeos de origen de eventos de AWS Lambda (p. 109)
• Monitorización del estado de una función con la API de Lambda (p. 113)
• Escalado de funciones de AWS Lambda (p. 114)
• Control de errores y reintentos automáticos en AWS Lambda (p. 119)
• Invocación de funciones Lambda con el SDK de AWS Mobile para Android (p. 121)

99
 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" }'
response.json
{
"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 response.json. 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. 72)) 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 response.json

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]

100
 AWS Lambda Guía para desarrolladores
Invocación asincrónica

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. 587).

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. 119).

Invocación asincrónica
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.

101
 AWS Lambda Guía para desarrolladores
Invocación asincrónica

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" }' response.json
{
"StatusCode": 202
}

El archivo de salida (response.json) 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.

102
 AWS Lambda Guía para desarrolladores
Invocación asincrónica

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. 104) 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. 104) para la invocación asincrónica.

• Amazon SQS: una cola de SQS estándar.

• Amazon SNS: un tema de SNS.

103
 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. 107) 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. 104)
• Configuración de destinos para invocación asincrónica (p. 104)
• API de configuración de invocación asincrónica (p. 106)
• Colas de mensajes fallidos de funciones de AWS Lambda (p. 107)

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.

104
 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. 33) 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).

105
 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

106
 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. 104), 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. 296) e invocar una función.

107
 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. 33) 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. 323) para ver un ejemplo.
• ErrorCode (número): el código de estado de HTTP.
• ErrorMessage (cadena): el primer 1 KB del mensaje de error.

108
 AWS Lambda Guía para desarrolladores
Mapeo de origen 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. 464). 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. 296).

Mapeos 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. 250)

• Amazon DynamoDB (p. 216)
• Amazon Simple Queue Service (p. 296)

Un mapeo de origen de eventos utiliza los permisos en el rol de ejecución (p. 33) 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:

109
 AWS Lambda Guía para desarrolladores
Mapeo de origen de eventos

• CreateEventSourceMapping (p. 517)

• ListEventSourceMappings (p. 598)
• GetEventSourceMapping (p. 555)
• UpdateEventSourceMapping (p. 653)
• DeleteEventSourceMapping (p. 536)

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.

110
 AWS Lambda Guía para desarrolladores
Mapeo de origen 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

111
 AWS Lambda Guía para desarrolladores
Mapeo de origen 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. 104) 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. 296), 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 Utilización de AWS Lambda con otros servicios (p. 163).

112
 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. 698) 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. 698) 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. 587)

• UpdateFunctionCode (p. 659)
• UpdateFunctionConfiguration (p. 667)
• PublishVersion (p. 624)

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.

113
 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. 659)

• UpdateFunctionConfiguration (p. 667)
• PublishVersion (p. 624)

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 de Lambda para obtener acceso a los recursos de una VPC (p. 81).

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

114
 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.

Cuotas de simultaneidad de ráfagas

• 3000: EE.UU. Oeste (Oregón), US East (N. Virginia), Europa (Irlanda).

• 1000: Asia Pacífico (Tokio), Europa (Fráncfort), EE.UU. Este (Ohio)
• 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.

115
 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.

116
 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. 62). 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. 20) 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. 62). 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

117
 AWS Lambda Guía para desarrolladores
Escalado de funciones

Cuando asigna simultaneidad aprovisionada, su función está lista para servir una ráfaga de 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. 67) 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.

118
 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 asincrónica (p. 101)

• Mapeos de origen de eventos de AWS Lambda (p. 109)
• Control de errores y reintentos automáticos en AWS Lambda (p. 119)
• Utilización de AWS Lambda con otros servicios (p. 163)

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 funciones de AWS Lambda (p. 464).

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. 130) 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.

119
 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. 587).

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 Node.js (p. 342)

• Errores de funciones de AWS Lambda en Python (p. 360)
• Errores de funciones AWS Lambda en Ruby (p. 376)
• Errores de la función AWS Lambda en Java (p. 404)
• Errores de funciones de AWS Lambda en Go (p. 427)
• Errores de funciones de AWS Lambda en C# (p. 447)
• Errores de la función AWS Lambda en PowerShell. (p. 462)

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 asincrónica (p. 101).
• 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. 464).

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 Mapeos de

120
 AWS Lambda Guía para desarrolladores
SDK de Mobile para Android

origen de eventos de AWS Lambda (p. 109) y los temas específicos del servicio en Utilización de AWS
Lambda con otros servicios (p. 163).
• AWS Services (Servicios de AWS ): los servicios de AWS pueden invocar la función de forma
síncrona (p. 100) 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 Utilización de AWS Lambda con otros servicios (p. 163) 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. 37) 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. 165).

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. 463).

Para ver una aplicación de muestra que utiliza una suscripción de CloudWatch Logs, el 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. 323).

Invocación de funciones 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. 122).

Al invocar una función desde una aplicación móvil, puede seleccionar la estructura del evento, el tipo de
invocación (p. 99) y el modelo de permisos. Puede utilizar los alias (p. 72) 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. 165).

Temas
• Tutorial: Uso de AWS Lambda con el SDK de Mobile para Android (p. 122)
• Código de función de ejemplo (p. 127)

121
 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. 33) 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.

122
 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 ejemplo (p. 127).

Example index.js

exports.handler = function(event, context, callback) {

console.log("Received event: ", event);
var data = {
"greetings": "Hello, " + event.firstName + " " + event.lastName + "."
};
callback(null, data);
}

Para crear la función

1. Copie el código de muestra en un archivo con el nombre index.js.

2. Crear un paquete de implementación.

$ zip function.zip index.js

3. Cree una función de Lambda con el comando create-function.

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

--zip-file fileb://function.zip --handler index.handler --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/lambda-android-role

Pruebe la función de 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, input.txt.

{ "firstName": "first-name", "lastName": "last-name" }

2. Ejecute el siguiente comando invoke:

$ aws lambda invoke --function-name AndroidBackendLambdaFunction \

123
 AWS Lambda Guía para desarrolladores
Tutorial

--payload file://file-path/input.txt outputfile.txt

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 las funciones de IAM, consulte Funciones 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"
]

124
 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 build.gradle (Module:app), añada lo siguiente en la sección dependencies:

compile 'com.amazonaws:aws-android-sdk-core:2.2.+'
compile 'com.amazonaws: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 (AndroidManifest.xml), 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="android.permission.INTERNET" />

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

5. En MainActivity, añada las siguientes importaciones:

import com.amazonaws.mobileconnectors.lambdainvoker.*;
import com.amazonaws.auth.CognitoCachingCredentialsProvider;
import com.amazonaws.regions.Regions;

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 com.example....lambdaeventgenerator;
public class RequestClass {
String firstName;
String lastName;

125
 AWS Lambda Guía para desarrolladores
Tutorial

public String getFirstName() {

return firstName;
}

public void setFirstName(String firstName) {

this.firstName = firstName;
}

public String getLastName() {

return lastName;
}

public void setLastName(String lastName) {

this.lastName = lastName;
}

public RequestClass(String firstName, String lastName) {

this.firstName = firstName;
this.lastName = lastName;
}

public RequestClass() {
}
}

• ResponseClass

package com.example....lambdaeventgenerator;
public class ResponseClass {
String greetings;

public String getGreetings() {

return greetings;
}

public void setGreetings(String greetings) {

this.greetings = greetings;
}

public ResponseClass(String greetings) {

this.greetings = greetings;
}

public ResponseClass() {
}
}

7. En el mismo paquete, cree una interfaz denominada MyInterface para invocar la función de
Lambda AndroidBackendLambdaFunction.

package com.example.....lambdaeventgenerator;
import com.amazonaws.mobileconnectors.lambdainvoker.LambdaFunction;
public interface MyInterface {

/**
* Invoke the Lambda function "AndroidBackendLambdaFunction".
* The function name is the method name.
*/
@LambdaFunction
ResponseClass AndroidBackendLambdaFunction(RequestClass request);

126
 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(
this.getApplicationContext(), "identity-pool-id", Regions.US_WEST_2);

// Create LambdaInvokerFactory, to be used to instantiate the Lambda proxy.

LambdaInvokerFactory factory = new LambdaInvokerFactory(this.getApplicationContext(),
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 = factory.build(MyInterface.class);

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 myInterface.AndroidBackendLambdaFunction(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
Toast.makeText(MainActivity.this, result.getGreetings(),
Toast.LENGTH_LONG).show();
}
}.execute(request);

9. Ejecute el código y verifíquelo como se indica a continuación:

• Toast.makeText() 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 ejemplo

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas

127
 AWS Lambda Guía para desarrolladores
Código de muestra

• Node.js (p. 128)

• Java (p. 128)

Node.js
El siguiente ejemplo utiliza datos para generar una respuesta de cadena.

Example index.js

exports.handler = function(event, context, callback) {

console.log("Received event: ", event);
var data = {
"greetings": "Hello, " + event.firstName + " " + event.lastName + "."
};
callback(null, data);
}

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 Node.js (p. 336).

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 HelloPojo.java

package example;

import com.amazonaws.services.lambda.runtime.Context;

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) {

this.firstName = firstName;
}

public String getLastName() {

return lastName;
}

public void setLastName(String lastName) {

this.lastName = lastName;
}

public RequestClass(String firstName, String lastName) {

this.firstName = firstName;
this.lastName = lastName;
}

128
 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) {

this.greetings = greetings;
}

public ResponseClass(String greetings) {

this.greetings = greetings;
}

public ResponseClass() {
}

public static ResponseClass myHandler(RequestClass request, Context context){

String greetingString = String.format("Hello %s, %s.", request.firstName,
request.lastName);
context.getLogger().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 de AWS Lambda en
Java (p. 386).

129
 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. 56) 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.171-105.231.amzn1.x86_64

Amazon Linux 2

• Imagen: personalizada
• Kernel de Linux – 4.14.165-102.205.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. 132) 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. 132) cuando la versión alcanza el fin de su vida útil.

Tiempos de ejecución de Node.js

Nombre Identifier AWS SDK para Sistema operativo

JavaScript

Node.js 12 nodejs12.x 2.631.0 Amazon Linux 2

Node.js nodejs10.x 2.631.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.12.49 Amazon Linux 2

botocore-1.15.49

Python 3.7 python3.7 boto3-1.12.49 Amazon Linux

botocore-1.15.49

Python 3.6 python3.6 boto3-1.12.49 Amazon Linux

botocore-1.15.49

130
 AWS Lambda Guía para desarrolladores

Nombre Identifier AWS SDK para Python Sistema operativo

Python 2.7 python2.7 boto3-1.12.49 Amazon Linux

botocore-1.15.49

Tiempos de ejecución 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

Tiempos de ejecución de Go

Nombre Identifier Sistema operativo

Go 1.x go1.x Amazon Linux

Runtimes de .NET

Nombre Identifier Sistema operativo

.NET Core 3.1 dotnetcore3.1 Amazon Linux 2

.NET Core 2.1 dotnetcore2.1 Amazon Linux

Para utilizar otros lenguajes en Lambda, puede implementar un tiempo de ejecución

personalizado (p. 134). El entorno de ejecución de Lambda proporciona una interfaz de tiempo de
ejecución (p. 136) 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. 76).

Tiempo de ejecución personalizado

Nombre Identifier Sistema operativo

Tiempo de ejecución provided Amazon Linux

personalizado

Temas
• Contexto de ejecución de AWS Lambda (p. 132)
• Política de soporte del tiempo de ejecución (p. 132)
• Tiempos de ejecución personalizados de AWS Lambda (p. 134)
• Interfaz de tiempo de ejecución de AWS Lambda (p. 136)

131
 AWS Lambda Guía para desarrolladores
Contexto de ejecución

• Tutorial: publicación de un tiempo de ejecución personalizado (p. 138)

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 Cuotas de AWS Lambda (p. 31).
• 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. 130) 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.

132
 AWS Lambda Guía para desarrolladores
Política de soporte del tiempo de ejecución

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.

Los siguientes tiempos de ejecución han quedado obsoletos:

Tiempos de ejecución obsoletos

Nombre Identifier Sistema operativo Fecha de finalización en

obsolescencia

.NET Core 1.0 dotnetcore1.0 Amazon Linux 30 de julio de 2019

.NET Core 2.0 dotnetcore2.0 Amazon Linux 30 de mayo de 2019

Node.js 0.10 nodejs Amazon Linux 31 de octubre de 2016

Node.js 4.3 nodejs4.3 Amazon Linux 6 de marzo de 2020

Node.js 4.3 edge nodejs4.3-edge Amazon Linux 30 de abril de 2019

Node.js 6.10 nodejs6.10 Amazon Linux 12 de agosto de 2019

Node.js 8.10 nodejs8.10 Amazon Linux 6 de marzo de 2020

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

• Node.js – github.com
• Python – devguide.python.org
• Ruby – www.ruby-lang.org
• Java – www.oracle.com y aws.amazon.com/corretto
• Go – golang.org
• .NET Core – dotnet.microsoft.com

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.

133
 AWS Lambda Guía para desarrolladores
Runtimes personalizados

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. 130) 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.

Para comenzar a utilizar tiempos de ejecución personalizados, consulte Tutorial: publicación de un tiempo
de ejecución personalizado (p. 138). 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. 134)
• Creación de un tiempo de ejecución personalizado (p. 134)

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. 76).

Example function.zip

.
### bootstrap
### function.sh

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 Node.js para
ejecutar un tiempo de ejecución de JavaScript en un archivo aparte llamado runtime.js.

Example arranque

#!/bin/sh
cd $LAMBDA_TASK_ROOT

134
 AWS Lambda Guía para desarrolladores
Creación de un tiempo de ejecución personalizado

./node-v11.1.0-linux-x64/bin/node runtime.js

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. 132) 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 file.method, 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. 58) la lista completa de variables
disponibles.
• 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. 138) 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. 311).

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. 136)
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.

135
 AWS Lambda Guía para desarrolladores
Interfaz de tiempo de ejecución

Procesamiento de tareas

• Obtener un evento–: llamar a la API de la siguiente invocación (p. 136) 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 localmente la variable de entorno
_X_AMZN_TRACE_ID con el mismo valor. El SDK de X-Ray utiliza este valor para conectar datos de
rastreo entre servicios.
• 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. 137) para publicar la respuesta
desde el controlador.
• Gestionar errores–: si se produce un error, llamar a la API de error de invocación (p. 138).
• Limpiar–: liberar recursos no utilizados, enviar datos a otros servicios o realizar tareas adicionales antes
de obtener el siguiente evento.

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. 138).

Interfaz de tiempo de ejecución de AWS Lambda

AWS Lambda proporciona una API HTTP para que los tiempos de ejecución personalizados (p. 134)
puedan recibir eventos de invocación desde Lambda y enviar los datos de respuesta dentro del entorno de
ejecución (p. 130) 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í: runtime-api.zip.

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 "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/next"

Recursos
• Siguiente invocación (p. 136)
• Respuesta de la invocación (p. 137)
• Error de invocación (p. 138)
• Error de inicialización (p. 138)

Siguiente invocación
Ruta: /runtime/invocation/next

Método: GET

136
 AWS Lambda Guía para desarrolladores
Respuesta de la invocación

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.

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 "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/
response" -d "SUCCESS"

137
 AWS Lambda Guía para desarrolladores
Error de invocación

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
ERROR="{\"errorMessage\" : \"Error parsing event data.\", \"errorType\" :
\"InvalidEventDataException\"}"
curl -X POST "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/
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 error de inicialización

ERROR="{\"errorMessage\" : \"Failed to load function.\", \"errorType\" :

\"InvalidFunctionException\"}"
curl -X POST "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/init/error" -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.

138
 AWS Lambda Guía para desarrolladores
Crear una función

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).
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. The HTTP request will block until one is received
EVENT_DATA=$(curl -sS -LD "$HEADERS" -X GET "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/
runtime/invocation/next")

139
 AWS Lambda Guía para desarrolladores
Crear una función

# Extract request ID by scraping response headers received above

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 "http://${AWS_LAMBDA_RUNTIME_API}/2018-06-01/runtime/invocation/$REQUEST_ID/
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. 134).

El script define una función de controlador que toma datos de eventos, la registra en stderr y la devuelve.

Example function.sh

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
# function.sh

Haga los archivos ejecutables y añádalos a un archivo ZIP.

runtime-tutorial$ chmod 755 function.sh bootstrap

runtime-tutorial$ zip function.zip function.sh bootstrap
adding: function.sh (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://function.zip --handler function.handler --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",

140
 AWS Lambda Guía para desarrolladores
Crear una capa

"Handler": "function.handler",
"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"}' response.txt
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
runtime-tutorial$ cat response.txt
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
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 runtime.zip 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://runtime.zip
{
"Content": {
"Location": "https://awslambda-us-west-2-layers.s3.us-west-2.amazonaws.com/
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.

141
 AWS Lambda Guía para desarrolladores
Actualización del 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 function-only.zip function.sh

adding: function.sh (deflated 24%)
runtime-tutorial$ aws lambda update-function-code --function-name bash-runtime --zip-file
fileb://function-only.zip
{
"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"}' response.txt
{
"StatusCode": 200,
"ExecutedVersion": "$LATEST"
}
runtime-tutorial$ cat response.txt
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:"

142
 AWS Lambda Guía para desarrolladores
Uso compartido de la capa

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 runtime.zip bootstrap

updating: bootstrap (deflated 39%)
runtime-tutorial$ aws lambda publish-layer-version --layer-name bash-runtime --zip-file
fileb://runtime.zip

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.

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.

Eliminar recursos
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

143
 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. 29) amplía AWS
CloudFormation con una sintaxis simplificada centrada en el desarrollo de aplicaciones de Lambda.

La AWS CLI (p. 29) y SAM CLI (p. 30) 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. 144)
• Creación de una aplicación con entrega continua en la consola de Lambda (p. 147)
• Implementaciones continuas para funciones de Lambda (p. 156)
• Tipos de aplicaciones de Lambda y casos de uso comunes (p. 157)
• Prácticas recomendadas para trabajar con funciones AWS Lambda (p. 159)

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. 144).
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.

2. Elija una aplicación.

144
 AWS Lambda Guía para desarrolladores
Monitorización de aplicaciones

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,
"height": 6,

145
 AWS Lambda Guía para desarrolladores
Paneles personalizados de monitorización

"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
Estructura y sintaxis del cuerpo del panel en la Referencia de la API de Amazon CloudWatch.

146
 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
Node.js y plantillas que crean recursos de soporte.

En este tutorial, se crean los recursos siguientes.

• Aplicación: una función de Node.js 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 procesada de AWS SAM 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. 33)
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 sobre AWS CodePipeline, consulte ¿Qué es AWS CodePipeline?.

Secciones
• Requisitos previos (p. 148)
• Cree una aplicación (p. 148)
• Describe cómo invocar la función. (p. 149)
• Añadir un recurso de AWS (p. 150)
• Actualizar el límite de permisos (p. 152)
• Actualizar el código de la función (p. 152)
• Pasos siguientes (p. 154)
• Solución de problemas (p. 154)

147
 AWS Lambda Guía para desarrolladores
Requisitos previos

• Eliminar recursos (p. 155)

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.

Cree una aplicación

Cree una aplicación en la consola de Lambda. En Lambda, una aplicación es una pila de AWS
CloudFormation con una función Lambda y cualquier cantidad de recursos de soporte. En este tutorial,
creará una aplicación que tenga una función y su rol de ejecución.

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: Node.js 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.

148
 AWS Lambda Guía para desarrolladores
Describe cómo invocar la función.

La pila Infraestructura contiene el repositorio, el proyecto de compilación y otros recursos que se combinan
para formar una canalización de entrega continua. Cuando esta pila termina de implementarse, a su vez
implementa la pila de aplicación que contiene la función y el rol de ejecución. Estos son los recursos de la
aplicación que aparecen en Recursos.

Describe cómo invocar la función.

Cuando finalice el proceso de implementación, invoque la función desde la consola de Lambda.

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.

• Nombre del evento: event

• 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.

149
 AWS Lambda Guía para desarrolladores
Añadir un recurso de AWS

Añadir un recurso de AWS

En el paso anterior, la consola de Lambda creó un repositorio de Git que contiene código de función, una
plantilla y una especificación de compilación. Puede añadir recursos a la aplicación modificando la plantilla
y enviando los cambios al repositorio. Para obtener una copia de la aplicación en su equipo local, clone el
repositorio.

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. 148).
5. Para clonar el repositorio, utilice el comando git clone.

~$ git clone ssh://git-codecommit.us-east-2.amazonaws.com/v1/repos/my-app-repo

Para agregar una tabla de DynamoDB a la aplicación, defina un recurso de

AWS::Serverless::SimpleTable en la plantilla.

Para agregar una tabla de DynamoDB

1. Abra template.yml 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 template.yml - Recursos

...
Resources:
ddbTable:
Type: AWS::Serverless::SimpleTable
Properties:

150
 AWS Lambda Guía para desarrolladores
Añadir un recurso de AWS

PrimaryKey:
Name: id
Type: String
ProvisionedThroughput:
ReadCapacityUnits: 1
WriteCapacityUnits: 1
helloFromLambdaFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./
Handler: src/handlers/hello-from-lambda.helloFromLambdaHandler
Runtime: nodejs10.x
MemorySize: 128
Timeout: 60
Description: A Lambda function that returns a static string.
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.

151
 AWS Lambda Guía para desarrolladores
Actualizar el límite de permisos

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. 50).

Actualizar el código de la función

A continuación, actualice el código de función para usar la tabla. El siguiente código utiliza la tabla de
DynamoDB 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 para la instancia de la función.

Para actualizar el código de la función

1. Agregue un nuevo controlador denominado index.js a la carpeta src/handlers con el siguiente

contenido.

Example src/handlers/index.js

const dynamodb = require('aws-sdk/clients/dynamodb');

const docClient = new dynamodb.DocumentClient();

exports.handler = async (event, context) => {

const message = 'Hello from Lambda!';
const tableName = process.env.DDB_TABLE;
const logStreamName = context.logStreamName;
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 docClient.update(params).promise();

const response = {
body: JSON.stringify(message)

152
 AWS Lambda Guía para desarrolladores
Actualizar el código de la función

};
console.log(`body: ${response.body}`);
return response;
}

2. Abra la plantilla de la aplicación y cambie el valor del controlador a src/handlers/

index.handler.

Example template.yml

...
helloFromLambdaFunction:
Type: AWS::Serverless::Function
Properties:
CodeUri: ./
Handler: src/handlers/index.handler
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).
4. Haga clic en Start search (Iniciar búsqueda).

Lambda crea instancias adicionales de su función para manejar múltiples invocaciones simultáneas.
Cada flujo de registro en el grupo de registros de CloudWatch Logs corresponde a una instancia de
función. También se crea una nueva instancia de función cuando se cambia el código o la configuración
de la función. Para obtener más información sobre el escalado, consulte Escalado de funciones de AWS
Lambda (p. 114).

153
 AWS Lambda Guía para desarrolladores
Pasos siguientes

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 Node.js, 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, cuotas 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).

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

154
 AWS Lambda Guía para desarrolladores
Eliminar recursos

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. 42) 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. 33) 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. 81) (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.

Eliminar recursos
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.

Los registros de la función no están asociados a la aplicación o la pila de infraestructura en AWS

CloudFormation. Elimine el grupo de registro por separado en la consola de CloudWatch Logs.

Para eliminar el grupo de registros

1. Abra la Log groups page (Página del grupo de registros) de la consola de Amazon CloudWatch.
2. Elija el grupo de registros de la función (/aws/lambda/my-app-
helloFromLambdaFunction-YV1VXMPLK7QK).
3. Elija Actions (Acciones) y, a continuación, elija Delete log group (Eliminar grupo de registro).
4. Elija Yes, Delete (Sí, eliminar).

155
 AWS Lambda Guía para desarrolladores
Implementaciones continuas

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
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.

Ejemplo de plantilla de Lambda de AWS SAM

En el siguiente ejemplo 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: myDateTimeFunction.handler
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.

156
 AWS Lambda Guía para desarrolladores
Casos de uso

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
Implementación de una función de Lambda actualizada con CodeDeploy.

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 Utilización de AWS Lambda con otros servicios (p. 163). Cuando se configuran estos orígenes

157
 AWS Lambda Guía para desarrolladores
Ejemplo 1: Amazon S3 envía eventos
e invoca una función de Lambda

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.

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. 33).
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. 37)
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. 517)

• UpdateEventSourceMapping (p. 653)

158
 AWS Lambda Guía para desarrolladores
Prácticas recomendadas

En el siguiente diagrama se muestra cómo una aplicación personalizada escribe registros en un flujo de
Kinesis.

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 AWS Lambda
A continuación se indican las prácticas recomendadas para utilizar AWS Lambda:

Temas
• Código de función (p. 159)
• Función de configuración (p. 160)
• Métricas y alarmas (p. 161)
• Uso de secuencias (p. 161)

Código de 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 Node.js, podría tener este aspecto:

exports.myHandler = function(event, context, callback) {

var foo = event.foo;
var bar = event.bar;
var result = MyLambdaFunction (foo, bar);

159
 AWS Lambda Guía para desarrolladores
Función de configuración

callback(null, result);
}

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. 56) 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 Node.js y Python (puede encontrar una lista completa aquí: Tiempos de ejecución de
AWS Lambda. (p. 130)). 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 de AWS Lambda en
Java (p. 386).
• 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. 132). 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

160
 AWS Lambda Guía para desarrolladores
Métricas y alarmas

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:

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. 33).
• Familiarícese con los Cuotas de AWS Lambda (p. 31). 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. 524) como a UpdateFunctionConfiguration (p. 667).
• 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.

Métricas y alarmas
• Utilice Trabajar con métricas de funciones de AWS Lambda (p. 464) 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.)

Uso de secuencias
• 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. 518) 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.

161
 AWS Lambda Guía para desarrolladores
Uso de secuencias

• 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).

162
 AWS Lambda Guía para desarrolladores

Utilización 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. 196).

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. 244) 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": "lambda-alb-123578498.us-east-2.elb.amazonaws.com",
"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": "72.12.164.125",
"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. 18). 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. 383)

163
 AWS Lambda Guía para desarrolladores

• Creación de funciones de Lambda con Go (p. 417)

• Creación de funciones Lambda con C# (p. 432)
• Creación de funciones de Lambda con PowerShell (p. 454)

En el caso de los servicios que generan una cola o un flujo de datos, debe crear un mapeo de origen de
eventos (p. 109) en Lambda y conceder a Lambda permiso para tener acceso al otro servicio en el rol de
ejecución (p. 33). Lambda lee los datos desde el otro servicio, crea un evento e invoca la función.

Servicios cuyos eventos lee Lambda

• Amazon Kinesis (p. 250)

• Amazon DynamoDB (p. 216)
• Amazon Simple Queue Service (p. 296)

Los demás servicios invocan la función directamente. Debe conceder al otro servicio permiso en la política
basada en recursos (p. 37) 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. 119).

Servicios que invocan funciones Lambda de forma síncrona

• Elastic Load Balancing (Balanceador de carga de aplicaciones) (p. 244)

• Amazon Cognito (p. 215)
• Amazon Lex (p. 265)
• Amazon Alexa (p. 165)
• Amazon API Gateway (p. 165)
• Amazon CloudFront (Lambda@Edge) (p. 205)
• Amazon Kinesis Data Firehose (p. 249)
• AWS Step Functions (p. 307)
• Lote de Amazon Simple Storage Service (p. 287)

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. 119) y puede
enviar los eventos con errores al destino (p. 104) que se haya configurado.

Servicios que invocan funciones Lambda de forma asíncrona

• Amazon Simple Storage Service (p. 272)

• Amazon Simple Notification Service (p. 290)
• Amazon Simple Email Service (p. 288)
• AWS CloudFormation (p. 203)
• Amazon CloudWatch Logs (p. 202)
• Amazon CloudWatch Events (p. 196)
• AWS CodeCommit (p. 207)
• AWS Config (p. 216)
• AWS IoT (p. 247)
• Eventos de AWS IoT (p. 248)
• AWS CodePipeline (p. 208)

164
 AWS Lambda Guía para desarrolladores
Alexa

Además, algunos servicios se integran con Lambda de otras maneras que no implican invocar funciones.

Servicios que integran Lambda de otras formas

• Amazon Elastic File System (p. 245)

• AWS X-Ray (p. 311)

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 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 Node.js

• Alexa Skills Kit SDK para Java

Example Evento de hogar digital de Alexa

{
"header": {
"payloadVersion": "1",
"namespace": "Control",
"name": "SwitchOnOffRequest"
},
"payload": {
"switchControlAction": "TURN_ON",
"appliance": {
"additionalApplianceDetails": {
"key2": "value2",
"key1": "value1"
},
"applianceId": "sampleId"
},
"accessToken": "sampleAccessToken"
}
}

Para obtener más información, consulte 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.

165
 AWS Lambda Guía para desarrolladores
API Gateway

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.
• /: (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. 100) 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 event.json: evento de proxy de API Gateway (REST API)

{
"resource": "/",
"path": "/",

166
 AWS Lambda Guía para desarrolladores
API Gateway

"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": "70ixmpl4fl.execute-api.us-east-2.amazonaws.com",
"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. 170) 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 Node.js. El objeto response
representa una respuesta HTTP correcta que contiene un documento JSON.

Example index.js: objeto de respuesta de integración de proxy (Node.js)

var response = {
"statusCode": 200,
"headers": {
"Content-Type": "application/json"
},
"isBase64Encoded": false,
"multiValueHeaders": {
"X-Custom-Header": ["My value", "My other value"],
},
"body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}"
}

El tiempo de ejecución de Lambda serializa el objeto response en un archivo JSON y lo envía a la API. La
API analiza la respuesta y la utiliza para crear una respuesta HTTP, que luego envía al cliente que realizó
la solicitud original.

167
 AWS Lambda Guía para desarrolladores
Permisos

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. 168)
• Administración de errores con una API de API Gateway (p. 170)
• Elegir un tipo de API (p. 170)
• Aplicaciones de muestra (p. 172)
• Tutorial: uso de AWS Lambda con Amazon API Gateway (p. 172)
• Código de función de ejemplo (p. 181)
• Creación de un microservicio sencillo utilizando Lambda y API Gateway (p. 183)
• Plantilla de AWS SAM para una aplicación de API Gateway (p. 185)

Permisos
Amazon API Gateway necesita permiso para invocar la función desde la política basada en
recursos (p. 37) de la función. Puede conceder permiso de invocación a toda una API o conceder acceso
limitado a una etapa, un recurso o un método.

Cuando agrega una API a la función utilizando la consola de Lambda, la consola de API Gateway o una
plantilla de AWS SAM, la política basada en recursos de la función se actualiza automáticamente. 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": "apigateway.amazonaws.com"
},
"Action": "lambda:InvokeFunction",

168
 AWS Lambda Guía para desarrolladores
Permisos

"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. 37) 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. 509)

• RemovePermission (p. 643)
• GetPolicy (p. 582)

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 apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/"
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike
\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET
\"}}}"
}

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.

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. 41).

169
 AWS Lambda Guía para desarrolladores
Administración de errores con una API de API Gateway

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 index.js: aplicar formato a un error

var formatError = function(error){

var response = {
"statusCode": error.statusCode,
"headers": {
"Content-Type": "text/plain",
"x-amzn-ErrorType": error.code
},
"isBase64Encoded": false,
"body": error.code + ": " + error.message
}
return response
}

API Gateway convierte esta respuesta en un error HTTP con un código de estado y un cuerpo
personalizados. En el mapa de seguimiento, el nodo de la función es verde porque el error se administró
correctamente.

Elegir un tipo de API

API Gateway admite tres tipos de API que invocan funciones Lambda:

• API HTTP: API RESTful ligera de baja latencia.

170
 AWS Lambda Guía para desarrolladores
Elegir un tipo de API

• 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.

Las API HTTP admiten un formato de evento simplificado (versión 2.0). En el ejemplo siguiente, se
muestra el evento de una API HTTP.

Example event-v2.json: evento de proxy (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": {

171
 AWS Lambda Guía para desarrolladores
Aplicaciones de muestra

"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": "r3pmxmplak.execute-api.us-east-2.amazonaws.com",
"domainPrefix": "r3pmxmplak",
"http": {
"method": "GET",
"path": "/default/nodejs-apig-function-1G3XMPLZXVXYI",
"protocol": "HTTP/1.1",
"sourceIp": "205.255.255.176",
"userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36"
},
"requestId": "JKJaXmPLvHcESHA=",
"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 muestra
El repositorio de GitHub para esta guía incluye la siguiente aplicación de ejemplo de API Gateway.

• API Gateway con Node.js: 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. 28) y plantillas (p. 29) que puede utilizar para crear una
aplicación de API Gateway en la consola de Lambda.

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.

172
 AWS Lambda Guía para desarrolladores
Tutorial

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"
}
}

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 la gateway API, consulte
Configuración de la integración del proxy para un recurso de proxy.

173
 AWS Lambda Guía para desarrolladores
Tutorial

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. 33) 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": [
"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"
}
]

174
 AWS Lambda Guía para desarrolladores
Tutorial

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 ejemplo (p. 181).

Example index.js

console.log('Loading function');

var AWS = require('aws-sdk');

var dynamo = new AWS.DynamoDB.DocumentClient();

/**
* 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
*/
exports.handler = function(event, context, callback) {
//console.log('Received event:', JSON.stringify(event, null, 2));

var operation = event.operation;

if (event.tableName) {
event.payload.TableName = event.tableName;
}

switch (operation) {
case 'create':
dynamo.put(event.payload, callback);
break;
case 'read':
dynamo.get(event.payload, callback);
break;
case 'update':
dynamo.update(event.payload, callback);
break;
case 'delete':
dynamo.delete(event.payload, callback);
break;
case 'list':
dynamo.scan(event.payload, callback);
break;
case 'echo':
callback(null, "Success");
break;
case 'ping':
callback(null, "pong");
break;
default:
callback('Unknown operation: ${operation}');
}

175
 AWS Lambda Guía para desarrolladores
Tutorial

};

Para crear la función

1. Copie el código de muestra en un archivo con el nombre index.js.

2. Crear un paquete de implementación.

$ zip function.zip index.js

3. Cree una función de Lambda con el comando create-function.

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

--zip-file fileb://function.zip --handler index.handler --runtime nodejs12.x \
--role arn:aws:iam::123456789012:role/service-role/lambda-apigateway-role

Prueba de la función de 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 input.txt.

{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}

2. Ejecute el siguiente comando invoke:

$ aws lambda invoke --function-name LambdaFunctionOverHttps \

--payload fileb://input.txt outputfile.txt

Creación de una API con Amazon API Gateway

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.

176
 AWS Lambda Guía para desarrolladores
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.

Creación de 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",
"pathPart": "DynamoDBManager",
"id": "iuig5w",
"parentId": "e8kitthgdb"
}

Anote el ID de la respuesta. Este es el ID del recurso DynamoDBManager que ha creado.

Creación de 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"
}

177
 AWS Lambda Guía para desarrolladores
Tutorial

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.

$ 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
}
}

178
 AWS Lambda Guía para desarrolladores
Tutorial

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 a la 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 (apigateway.amazonaws.com) 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 apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/*/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"apigateway.amazonaws.com\"},\"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
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 apigateway.amazonaws.com \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/prod/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-prod-2\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"apigateway.amazonaws.com\"},\"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.

179
 AWS Lambda Guía para desarrolladores
Tutorial

Crear 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 create-item.json

{
"operation": "create",
"tableName": "lambda-apigateway",
"payload": {
"Item": {
"id": "1234ABCD",
"number": 5
}
}
}

Guarde la información de pruebas en un archivo llamado create-item.json. 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 file://create-item.json

También puede utilizar el siguiente comando Curl:

$ curl -X POST -d "{\"operation\":\"create\",\"tableName\":\"lambda-apigateway\",

\"payload\":{\"Item\":{\"id\":\"1\",\"name\":\"Bob\"}}}" https://$API.execute-api.
$REGION.amazonaws.com/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:

180
 AWS Lambda Guía para desarrolladores
Código de muestra

Example echo.json

{
"operation": "echo",
"payload": {
"somekey1": "somevalue1",
"somekey2": "somevalue2"
}
}

Guarde la información de pruebas en un archivo llamado echo.json. 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 file://echo.json

También puede utilizar el siguiente comando Curl:

$ curl -X POST -d "{\"operation\":\"echo\",\"payload\":{\"somekey1\":\"somevalue1\",

\"somekey2\":\"somevalue2\"}}" https://$API.execute-api.$REGION.amazonaws.com/prod/
DynamoDBManager

Código de función de ejemplo

El código de muestra está disponible para los lenguajes que se indican a continuación.

Temas
• Node.js (p. 181)
• Python 3 (p. 182)
• Go (p. 183)

Node.js
El siguiente ejemplo procesa mensajes desde API Gateway y administra documentos DynamoDB basados
en el método requerido.

Example index.js

console.log('Loading function');

var AWS = require('aws-sdk');

var dynamo = new AWS.DynamoDB.DocumentClient();

/**
* 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
*/
exports.handler = function(event, context, callback) {
//console.log('Received event:', JSON.stringify(event, null, 2));

var operation = event.operation;

181
 AWS Lambda Guía para desarrolladores
Código de muestra

if (event.tableName) {
event.payload.TableName = event.tableName;
}

switch (operation) {
case 'create':
dynamo.put(event.payload, callback);
break;
case 'read':
dynamo.get(event.payload, callback);
break;
case 'update':
dynamo.update(event.payload, callback);
break;
case 'delete':
dynamo.delete(event.payload, callback);
break;
case 'list':
dynamo.scan(event.payload, 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 de AWS Lambda en Node.js (p. 336).

Python 3
El siguiente ejemplo procesa mensajes desde API Gateway y administra documentos DynamoDB basados
en el método requerido.

Example LambdaFunctionOverHttps.py

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: " + json.dumps(event, indent=2))

operation = event['operation']

if 'tableName' in event:
dynamo = boto3.resource('dynamodb').Table(event['tableName'])

182
 AWS Lambda Guía para desarrolladores
Proyecto de microservicio

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: dynamo.scan(**x),
'echo': lambda x: x,
'ping': lambda x: 'pong'
}

if operation in operations:
return operations[operation](event.get('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. 352).

Go
El siguiente ejemplo procesa mensajes desde API Gateway y registra información basada en la petición.

Example LambdaFunctionOverHttps.go

import (
"strings"
"github.com/aws/aws-lambda-go/events"
)

func handleRequest(ctx context.Context, request events.APIGatewayProxyRequest)

(events.APIGatewayProxyResponse, error) {
fmt.Printf("Processing request data for request %s.\n",
request.RequestContext.RequestId)
fmt.Printf("Body size = %d.\n", len(request.Body))

fmt.Println("Headers:")
for key, value := range request.Headers {
fmt.Printf(" %s: %s\n", key, value)
}

return events.APIGatewayProxyResponse { Body: request.Body, StatusCode: 200 }, nil

}

Compile el ejecutable con go build y cree un paquete de implementación. Para obtener instrucciones,
consulte Paquete de implementación de AWS Lambda en Go (p. 417).

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

183
 AWS Lambda Guía para desarrolladores
Proyecto de microservicio

Creación de una API con Amazon API Gateway

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.

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 de proxy para un recurso de 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 de DynamoDB con un flujo habilitado (p. 226)

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.

184
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

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. 172). 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 template.yaml

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
LambdaFunctionOverHttps:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: nodejs12.x
Policies: AmazonDynamoDBFullAccess
Events:
HttpPost:
Type: Api
Properties:
Path: '/DynamoDBOperations/DynamoDBManager'
Method: post

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 Implementación de aplicaciones sin servidor
en la Guía para desarrolladores de Modelo 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",

185
 AWS Lambda Guía para desarrolladores
CloudTrail

"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":"sns.amazonaws.com",
"eventName":"CreateTopic",
"awsRegion":"us-east-2",
"sourceIPAddress":"205.251.233.176",
"userAgent":"console.amazonaws.com",
"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",
"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":"sns.amazonaws.com",
"eventName":"GetTopicAttributes",
"awsRegion":"us-east-2",
"sourceIPAddress":"205.251.233.176",
"userAgent":"console.amazonaws.com",
"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 Amazon S3 (p. 272).

186
 AWS Lambda Guía para desarrolladores
Registros de CloudTrail

Temas
• Registrar llamadas a la API de AWS Lambda con AWS CloudTrail (p. 187)
• Tutorial: Activación de una función Lambda con eventos de AWS CloudTrail (p. 190)
• Código de función de muestra (p. 195)

Registrar 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.

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. 509)

• CreateEventSourceMapping (p. 517)
• CreateFunction (p. 524)

187
 AWS Lambda Guía para desarrolladores
Registros de CloudTrail

(Se omite el parámetro ZipFile de los registros de CloudTrail para CreateFunction).

• DeleteEventSourceMapping (p. 536)
• DeleteFunction (p. 540)
• GetEventSourceMapping (p. 555)
• GetFunction (p. 559)
• GetFunctionConfiguration (p. 565)
• GetPolicy (p. 582)
• ListEventSourceMappings (p. 598)
• ListFunctions (p. 604)
• RemovePermission (p. 643)
• UpdateEventSourceMapping (p. 653)
• UpdateFunctionCode (p. 659)

(Se omite el parámetro ZipFile de los registros de CloudTrail para UpdateFunctionCode).

• UpdateFunctionConfiguration (p. 667)

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,
o mediante otro servicio de AWS. Para obtener más información, consulte el campo userIdentity en la
Referencia de eventos de CloudTrail.

Puede almacenar los archivos de log en su bucket todo el tiempo que desee, y también puede definir
reglas de ciclo de vida de Amazon S3 para archivar o eliminar archivos de log 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": {

188
 AWS Lambda Guía para desarrolladores
Registros de CloudTrail

"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "myUserName"
},
"eventTime": "2015-03-18T19:03:36Z",
"eventSource": "lambda.amazonaws.com",
"eventName": "GetFunction",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"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": {
"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"accessKeyId": "AKIAIOSFODNN7EXAMPLE",
"userName": "myUserName"
},
"eventTime": "2015-03-18T19:04:42Z",
"eventSource": "lambda.amazonaws.com",
"eventName": "DeleteFunction",
"awsRegion": "us-east-1",
"sourceIPAddress": "127.0.0.1",
"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é

189
 AWS Lambda Guía para desarrolladores
Tutorial

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.

Uso de CloudTrail para solucionar problemas de orígenes de eventos

deshabilitados
Un evento de datos que se puede encontrar es un evento LambdaESMDisabled. Hay cinco categorías
generales de error asociadas a este evento:

RESOURCE_NOT_FOUND

El recurso especificado en la solicitud no existe.

FUNCTION_NOT_FOUND

La función adjunta al origen del evento no existe.

REGION_NAME_NOT_VALID

Un nombre de región proporcionado en la función o el origen del evento no es válido.

AUTHORIZATION_ERROR

Los permisos no se han establecido o están mal configurados.

FUNCTION_IN_FAILED_STATE

El código de función no se compila, se ha detectado una excepción irrecuperable o ha ocurrido una

implementación incorrecta.

Estos errores se incluyen en el mensaje de evento de CloudTrail dentro de la entidad

serviceEventDetails.

Example Entidad serviceEventDetails

"serviceEventDetails":{
"ESMDisableReason":"Lambda Function not found"
}

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.
• 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.

190
 AWS Lambda Guía para desarrolladores
Tutorial

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:

• Node.js 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.

Paso 3: creación de un rol de ejecución de IAM

Un rol de ejecución (p. 33) 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.

191
 AWS Lambda Guía para desarrolladores
Tutorial

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 index.js.
3. Pegue el siguiente código en index.js. Sustituya el ARN del tema de Amazon SNS por el ARN que
Amazon S3 creó cuando se creó el tema de Amazon SNS.

var aws = require('aws-sdk');

var zlib = require('zlib');
var async = require('async');

var EVENT_SOURCE_TO_TRACK = /sns.amazonaws.com/;

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';

192
 AWS Lambda Guía para desarrolladores
Tutorial

var s3 = new aws.S3();

var sns = new aws.SNS({
apiVersion: '2010-03-31',
region: DEFAULT_SNS_REGION
});

exports.handler = function(event, context, callback) {

var srcBucket = event.Records[0].s3.bucket.name;
var srcKey = event.Records[0].s3.object.key;

async.waterfall([
function fetchLogFromS3(next){
console.log('Fetching compressed log from S3...');
s3.getObject({
Bucket: srcBucket,
Key: srcKey
},
next);
},
function uncompressLog(response, next){
console.log("Uncompressing log...");
zlib.gunzip(response.Body, next);
},
function publishNotifications(jsonBuffer, next) {
console.log('Filtering log...');
var json = jsonBuffer.toString();
console.log('CloudTrail JSON from S3:', json);
var records;
try {
records = JSON.parse(json);
} catch (err) {
next('Unable to parse CloudTrail JSON: ' + err);
return;
}
var matchingRecords = records
.Records
.filter(function(record) {
return record.eventSource.match(EVENT_SOURCE_TO_TRACK)
&& record.eventName.match(EVENT_NAME_TO_TRACK);
});

console.log('Publishing ' + matchingRecords.length + ' notification(s) in

parallel...');
async.each(
matchingRecords,
function(record, publishComplete) {
console.log('Publishing notification: ', record);
sns.publish({
Message:
'Alert... SNS topic created: \n TopicARN=' +
record.responseElements.topicArn + '\n\n' +
JSON.stringify(record),
TopicArn: SNS_TOPIC_ARN
}, publishComplete);
},
next
);
}
], function (err) {
if (err) {
console.error('Failed to publish notifications: ', err);
} else {
console.log('Successfully published all notifications.');
}
callback(null,"message");
});

193
 AWS Lambda Guía para desarrolladores
Tutorial

};

4. En la carpeta lambda-cloudtrail ejecute el siguiente script. Crea un archivo package-

lock.json 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 function.zip .

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://function.zip --handler index.handler --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 s3.amazonaws.com \
--source-arn arn:aws:s3:::my-bucket \
--source-account 123456789012

Este comando concede a la entidad principal del servicio Amazon S3 (s3.amazonaws.com) 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

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.

194
 AWS Lambda Guía para desarrolladores
Código de muestra

• 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
• Node.js (p. 195)

Node.js
El ejemplo siguiente procesa registros de CloudTrail y envía una notificación cuando se crea un tema de
Amazon SNS.

Example index.js

var aws = require('aws-sdk');

var zlib = require('zlib');
var async = require('async');

var EVENT_SOURCE_TO_TRACK = /sns.amazonaws.com/;

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 aws.SNS({
apiVersion: '2010-03-31',
region: DEFAULT_SNS_REGION
});

exports.handler = function(event, context, callback) {

var srcBucket = event.Records[0].s3.bucket.name;
var srcKey = event.Records[0].s3.object.key;

async.waterfall([
function fetchLogFromS3(next){
console.log('Fetching compressed log from S3...');
s3.getObject({
Bucket: srcBucket,

195
 AWS Lambda Guía para desarrolladores
Eventos de CloudWatch

Key: srcKey
},
next);
},
function uncompressLog(response, next){
console.log("Uncompressing log...");
zlib.gunzip(response.Body, next);
},
function publishNotifications(jsonBuffer, next) {
console.log('Filtering log...');
var json = jsonBuffer.toString();
console.log('CloudTrail JSON from S3:', json);
var records;
try {
records = JSON.parse(json);
} catch (err) {
next('Unable to parse CloudTrail JSON: ' + err);
return;
}
var matchingRecords = records
.Records
.filter(function(record) {
return record.eventSource.match(EVENT_SOURCE_TO_TRACK)
&& record.eventName.match(EVENT_NAME_TO_TRACK);
});

console.log('Publishing ' + matchingRecords.length + ' notification(s) in

parallel...');
async.each(
matchingRecords,
function(record, publishComplete) {
console.log('Publishing notification: ', record);
sns.publish({
Message:
'Alert... SNS topic created: \n TopicARN=' +
record.responseElements.topicArn + '\n\n' +
JSON.stringify(record),
TopicArn: SNS_TOPIC_ARN
}, publishComplete);
},
next
);
}
], function (err) {
if (err) {
console.error('Failed to publish notifications: ', err);
} else {
console.log('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 de AWS Lambda en Node.js (p. 336).

Uso de AWS Lambda con Amazon CloudWatch

Events
Eventos de Amazon CloudWatch 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.

196
 AWS Lambda Guía para desarrolladores
Eventos de CloudWatch

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
AWS Lambda para registrar el estado de una instancia EC2 o un grupo de AutoScaling.

Eventos de CloudWatch invoca su función de forma asíncrona con un documento de evento que envuelve
el evento desde su origen. En el siguiente ejemplo se muestra un evento que se originó a partir de una
instantánea de base de datos de Amazon Relational Database Service.

Example Eventos de CloudWatch event

{
"version": "0",
"id": "fe8d3c65-xmpl-c5c3-2c87-81584709a377",
"detail-type": "RDS DB Instance Event",
"source": "aws.rds",
"account": "123456789012",
"time": "2020-04-28T07:20:20Z",
"region": "us-east-2",
"resources": [
"arn:aws:rds:us-east-2:123456789012:db:rdz6xmpliljlb1"
],
"detail": {
"EventCategories": [
"backup"
],
"SourceType": "DB_INSTANCE",
"SourceArn": "arn:aws:rds:us-east-2:123456789012:db:rdz6xmpliljlb1",
"Date": "2020-04-28T07:20:20.112Z",
"Message": "Finished DB Instance backup",
"SourceIdentifier": "rdz6xmpliljlb1"
}
}

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.

Example Evento de mensaje de Eventos de CloudWatch

{
"account": "123456789012",
"region": "us-east-2",
"detail": {},
"detail-type": "Scheduled Event",
"source": "aws.events",
"time": "2019-03-01T01:23:45Z",
"id": "cdc73f9d-aea9-11e3-9d5a-835b769c0d9c",
"resources": [
"arn:aws:events:us-east-1:123456789012:rule/my-schedule"
]
}

Para configurar Eventos de CloudWatch para invocar su función

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. Establezca el tipo de desencadenador en Eventos de CloudWatch/EventBridge.
5. En Rule (Regla), elija Create a new rule (Crear una nueva regla).

197
 AWS Lambda Guía para desarrolladores
Tutorial

6. Configure las opciones restantes y elija Añadir.

Para obtener más información sobre las expresiones de programación, consulte Programación de
expresiones con rate o cron (p. 201).

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.

Temas
• Tutorial: Uso de AWS Lambda con eventos programados (p. 198)
• Plantilla de AWS SAM para una aplicación de Eventos de CloudWatch (p. 200)
• Programación de expresiones con rate o cron (p. 201)

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.

Crear una función de Lambda

1. Inicie sesión en la Consola de administración de AWS y abra la consola de AWS Lambda en https://
console.aws.amazon.com/lambda/.
2. Elija Create function (Crear función).
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.

198
 AWS Lambda Guía para desarrolladores
Tutorial

• 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: https://docs.aws.amazon.com/lambda/latest/dg/welcome.html
• expected (esperado): What is AWS Lambda?
6. Elija Create function.

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. 201).

Pruebe la función de 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.

199
 AWS Lambda Guía para desarrolladores
Plantilla de muestra

Amazon SNS envía un email desde Canary <[email protected]>, 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.
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 Aspectos básicos sobre plantillas AWS SAM en la Guía para
desarrolladores de Modelo 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. 198). Copie el texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha

200
 AWS Lambda Guía para desarrolladores
Programación de expresiones

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 template.yaml

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Parameters:
NotificationEmail:
Type: String
Resources:
CheckWebsitePeriodically:
Type: AWS::Serverless::Function
Properties:
Handler: LambdaFunctionOverHttps.handler
Runtime: runtime
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ón sobre cómo empaquetar e implementar una aplicación sin servidor usando
los comandos de empaquetado e implementación, consulte Implementación de aplicaciones sin servidor
en la Guía para desarrolladores de Modelo 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)).

201
 AWS Lambda Guía para desarrolladores
Registros de CloudWatch

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)

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

202
 AWS Lambda Guía para desarrolladores
CloudFormation

"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",
"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. 323).

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 primer.Arn
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. 101) con un evento que incluye
una URL de devolución de llamada.

203
 AWS Lambda Guía para desarrolladores
CloudFormation

Example – Evento de mensaje de AWS CloudFormation

{
"RequestType": "Create",
"ServiceToken": "arn:aws:lambda:us-east-2:123456789012:function:lambda-error-processor-
primer-14ROR2T3JKU66",
"ResponseURL": "https://cloudformation-custom-resource-response-useast2.s3-us-
east-2.amazonaws.com/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",
"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/template.yml: función de recurso personalizado

Transform: 'AWS::Serverless-2016-10-31'
Resources:
primer:
Type: AWS::Serverless::Function
Properties:
Handler: index.handler
Runtime: nodejs12.x
InlineCode: |
var aws = require('aws-sdk');

204
 AWS Lambda Guía para desarrolladores
CloudFront (Lambda@Edge)

var response = require('cfn-response');

exports.handler = function(event, context) {
// For Delete requests, immediately send a SUCCESS response.
if (event.RequestType == "Delete") {
response.send(event, context, "SUCCESS");
return;
}
var responseStatus = "FAILED";
var responseData = {};
var functionName = event.ResourceProperties.FunctionName
var lambda = new aws.Lambda();
lambda.invoke({ FunctionName: functionName }, function(err, invokeResult) {
if (err) {
responseData = {Error: "Invoke call failed"};
console.log(responseData.Error + ":\n", err);
}
else responseStatus = "SUCCESS";
response.send(event, context, responseStatus, responseData);
});
};
Description: Invoke a function to create a log stream.
MemorySize: 128
Timeout: 8
Role: !GetAtt role.Arn
Tracing: Active

Si la función que el recurso personalizado invoca no está 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. 323).

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 Node.js 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)

205
 AWS Lambda Guía para desarrolladores
CloudFront (Lambda@Edge)

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.

Example Evento de mensaje de CloudFront

{
"Records": [
{
"cf": {
"config": {
"distributionId": "EDFDVBD6EXAMPLE"
},
"request": {
"clientIp": "2001:0db8:85a3:0:0:8a2e:0370:7334",
"method": "GET",
"uri": "/picture.jpg",
"headers": {
"host": [
{
"key": "Host",
"value": "d111111abcdef8.cloudfront.net"
}
],
"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.

206
 AWS Lambda Guía para desarrolladores
CodeCommit

• 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.

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": "index.handler",
"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.

207
 AWS Lambda Guía para desarrolladores
CodePipeline

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. 144) 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 CodePipeline event

{
"CodePipeline.job": {
"id": "c0d76431-b0e7-xmpl-97e3-e8ee786eb6f6",
"accountId": "123456789012",
"data": {
"actionConfiguration": {
"configuration": {
"FunctionName": "my-function",
"UserParameters": "{\"KEY\": \"VALUE\"}"
}
},
"inputArtifacts": [
{
"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
}
}
}
}

208
 AWS Lambda Guía para desarrolladores
Permisos

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 Node.js 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 index.js

var AWS = require('aws-sdk')

var codepipeline = new AWS.CodePipeline()

exports.handler = async (event) => {

console.log(JSON.stringify(event, null, 2))
var jobId = event["CodePipeline.job"].id
var params = {
jobId: jobId
}
return codepipeline.putJobSuccessResult(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. 119). Configure la función con un destino (p. 104) 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
• Permisos (p. 209)
• Creación de una canalización de entrega continua para una aplicación de Lambda con AWS
CodePipeline (p. 210)

Permisos
Para invocar una función, una canalización CodePipeline necesita permiso para utilizar las siguientes
operaciones de la API:

• ListFunctions (p. 604)

• InvokeFunction (p. 587)

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. 33).

• codepipeline:PutJobSuccessResult
• codepipeline:PutJobFailureResult

Estos permisos se incluyen en la política administrada AwsCodePipelineCustomActionAccess.

209
 AWS Lambda Guía para desarrolladores
Tutorial

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.

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 sobre 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. 211)
• Cree de un rol de AWS CloudFormation. (p. 211)
• Configuración de un repositorio (p. 212)
• Cree una canalización (p. 213)
• Actualización del rol de la etapa de compilación (p. 214)
• Finalización de la etapa de implementación (p. 214)
• Pruebe la aplicación. (p. 215)

210
 AWS Lambda Guía para desarrolladores
Tutorial

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

Cree de un rol de 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.

• 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",

211
 AWS Lambda Guía para desarrolladores
Tutorial

"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 index.js
Una función de Lambda que devuelve la hora actual.

var time = require('time');

exports.handler = (event, context, callback) => {
var currentTime = new time.Date();
currentTime.setTimezone("America/Los_Angeles");
callback(null, {
statusCode: '200',
body: 'The time in Los Angeles is: ' + currentTime.toString(),
});
};

Example template.yml
La plantilla de AWS SAM (p. 29) 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: index.handler
Runtime: nodejs10.x
CodeUri: ./
Events:
MyTimeApi:
Type: Api
Properties:
Path: /TimeResource
Method: GET

212
 AWS Lambda Guía para desarrolladores
Tutorial

Example buildspec.yml

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 template.yml --s3-bucket $BUCKET --
output-template-file outputtemplate.yml
artifacts:
type: zip
files:
- template.yml
- outputtemplate.yml

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

Cree 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.

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).

213
 AWS Lambda Guía para desarrolladores
Tutorial

• 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): buildspec.yml
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::outputtemplate.yml
• 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.

2. Elija codebuild-lamba-pipeline-build-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).

214
 AWS Lambda Guía para desarrolladores
Cognito

• 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.

Pruebe 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, https://l193nqxdjj.execute-
api.us-east-2.amazonaws.com/Prod/TimeResource.
6. Abra la URL.

La API devuelve la hora actual con el siguiente formato.

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",

215
 AWS Lambda Guía para desarrolladores
Config

"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\":
\"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.

216
 AWS Lambda Guía para desarrolladores
DynamoDB

Lambda lee los registros del flujo e invoca la función de forma síncrona (p. 100) 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 Evento de registro de Flujos de DynamoDB

{
"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": {
"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",

217
 AWS Lambda Guía para desarrolladores
Permisos de rol de ejecución

"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. 218)
• Configuración de una secuencia como origen de eventos (p. 219)
• API de mapeo de origen de eventos (p. 220)
• Control de errores (p. 221)
• Métricas de Amazon CloudWatch (p. 222)
• Tutorial: Uso de AWS Lambda con flujos de Amazon DynamoDB (p. 223)
• Código de función de ejemplo (p. 227)
• Plantilla de AWS SAM para una aplicación de DynamoDB (p. 230)

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. 33).

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

218
 AWS Lambda Guía para desarrolladores
Configuración de una secuencia como origen de eventos

• Amazon SNS: sns:Publish

Configuración de una secuencia como 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. 31) 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 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): establecer en true para habilitar la asignación de origen de eventos. Establecer
en false 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.

219
 AWS Lambda Guía para desarrolladores
API de mapeo de origen de eventos

Note

DynamoDB cobra por las solicitudes de lectura que Lambda hace para obtener registros de la
secuencia. Para obtener más información sobre precios, consulte precios de Amazon DynamoDB.

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. 517)

• ListEventSourceMappings (p. 598)
• GetEventSourceMapping (p. 555)
• UpdateEventSourceMapping (p. 653)
• DeleteEventSourceMapping (p. 536)

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
}

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-