Lambda DG

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.
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
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
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
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
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
Proyecto de microservicio ................................................................................................. 183
Plantilla de muestra ......................................................................................................... 185
CloudTrail .............................................................................................................................. 185
Registros de CloudTrail .................................................................................................... 187
Tutorial .......................................................................................................................... 190
Eventos de CloudWatch ........................................................................................................... 196
Tutorial .......................................................................................................................... 198
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
EC2 ...................................................................................................................................... 231
Permisos ........................................................................................................................ 232
Tutorial: Instancias de spot ............................................................................................... 232
ElastiCache ............................................................................................................................ 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
vi
Configuración de una secuencia como un origen de eventos ................................................. 253

Control de errores ........................................................................................................... 256
Métricas de Amazon CloudWatch ...................................................................................... 257
Tutorial .......................................................................................................................... 257
Lex ....................................................................................................................................... 265
Roles y permisos ............................................................................................................ 267
RDS ...................................................................................................................................... 268
Tutorial: Amazon RDS ..................................................................................................... 269
S3 ......................................................................................................................................... 272
Tutorial .......................................................................................................................... 273
Lote S3 ................................................................................................................................. 287
Invocación de funciones de Lambda desde operaciones por lotes de Amazon S3 ...................... 288
SES ...................................................................................................................................... 288
SNS ...................................................................................................................................... 290
Tutorial .......................................................................................................................... 291
SQS ...................................................................................................................................... 296
Escalado y procesamiento ................................................................................................ 298
Configuración de una cola para el uso con Lambda ............................................................. 298
Configuración de una cola como origen de eventos .............................................................. 299
Tutorial .......................................................................................................................... 300
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
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
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
Almacenamiento de dependencias en tiempo de ejecución en una capa .................................. 347
Uso de Python ................................................................................................................................ 349
Controlador ............................................................................................................................ 351
Con un entorno virtual ..................................................................................................... 354
Contexto ................................................................................................................................ 355
Registro ................................................................................................................................. 357
Mediante AWS CLI .......................................................................................................... 358
Biblioteca de registro ....................................................................................................... 360
Errores .................................................................................................................................. 360
Tracing .................................................................................................................................. 361
Uso de Ruby .................................................................................................................................. 367
Controlador ............................................................................................................................ 369
Contexto ................................................................................................................................ 371
Registro ................................................................................................................................. 372
Mediante AWS CLI .......................................................................................................... 358
Errores .................................................................................................................................. 376
Tracing .................................................................................................................................. 378
Uso de Java ................................................................................................................................... 383
Aplicaciones de ejemplo ........................................................................................................... 384
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
Contexto ................................................................................................................................ 396

Contexto en aplicaciones de ejemplo ................................................................................. 398
Registro ................................................................................................................................. 398
Mediante AWS CLI .......................................................................................................... 400
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
Seguimiento en las aplicaciones de ejemplo ........................................................................ 413
Tutorial: IDE de Eclipse ........................................................................................................... 414
Creación y compilación de un proyecto .............................................................................. 415
Uso de Go ..................................................................................................................................... 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
Mediante AWS CLI .......................................................................................................... 425
Errores .................................................................................................................................. 427
Tracing .................................................................................................................................. 427
Variables de entorno ............................................................................................................... 431
Trabajar con C# .............................................................................................................................. 432
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
Mediante AWS CLI .......................................................................................................... 446
Errores .................................................................................................................................. 447
Tracing .................................................................................................................................. 450
ix

Trabajar con PowerShell .................................................................................................................. 454
Entorno de desarrollo .............................................................................................................. 454
Controlador ............................................................................................................................ 457
Devolución de datos ........................................................................................................ 457
Contexto ................................................................................................................................ 458
Registro ................................................................................................................................. 458
Mediante AWS CLI .......................................................................................................... 460
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
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
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
¿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
¿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
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
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
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
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
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
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
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.

Utilice el panel de edición del editor de código para ver y escribir código.
9
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
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
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 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 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": {
},
}
]
}
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
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_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,
}
{
"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 ...",
},
{
"timestamp": 1559763003173,
\tINFO\tEVENT\r{\r \"key\": \"value\"\r}\n",
},
{
"timestamp": 1559763003218,
"message": "END RequestId: 4ce9340a-b765-490f-ad8a-02ab3415e2bf\n",
},
{
"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
Listado de las funciones Lambda de su cuenta
}
],
"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",
...
},
{
"FunctionName": "random-error",
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:random-error",
"Role": "arn:aws:iam::123456789012:role/lambda-role",
...
},
...
],
"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": {
"CodeSha256": "FpFMvUhayLkOoVBpNuNiIVML/tuGv2iJQ7t0yWVTU8c=",
"TracingConfig": {
17
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
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
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
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
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
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.
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
Controles de simultaneidad
Para obtener más información, consulte Escalado de funciones de AWS Lambda (p. 114).
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
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
Invocación asincrónica
Para obtener más información, consulte Administración de la simultaneidad para una función de
Lambda (p. 62).
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
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).

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
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
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
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
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
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)
Python • Consola de AWS Lambda

• PyCharm, con el AWS Toolkit for PyCharm
Ruby • Consola de AWS Lambda

Go • Su propio entorno de desarrollo
30
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
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
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
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

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
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",
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
},
}
]
}
}
}
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
Políticas administradas para características de Lambda
Example trust-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
},
}
]
}
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
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

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

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.

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

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)

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

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

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

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

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.
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
Código de muestra y plantillas
• UpdateFunctionConfiguration (p. 667)

• 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

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

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

3. En Concurrency (Simultaneidad), elija Reserve concurrency (Reservar simultaneidad).
4. Escriba la cantidad de simultaneidad que reservar para la función.
62
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
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.

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

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
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
Leyenda
• Instancias de función
• Solicitudes abiertas
• 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
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).

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.

• GetFunctionConcurrency
• 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 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
disminuir. Cuando el uso es consistentemente bajo, Auto Scaling de aplicaciones reduce la simultaneidad
aprovisionada en pasos periódicos más pequeños.
Leyenda
Para consultar las cuotas de simultaneidad de su cuenta en una región, utilice get-account-settings.
$ aws lambda get-account-settings

{
69
Versiones
"AccountLimit": {
"TotalCodeSize": 80530636800,
"CodeSizeUnzipped": 262144000,
"CodeSizeZipped": 52428800,
"ConcurrentExecutions": 1000,
"UnreservedConcurrentExecutions": 900
},
"AccountUsage": {
"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

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

{
"FunctionArn": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Version": "1",
"Handler": "function.handler",
...
}
Uso de versiones
El ARN permite hacer referencia a la función de Lambda. Existen dos ARN asociados a esta versión inicial:
71
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.
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

3. En Actions (Acciones), elija Create alias (Crear alias).
72
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:

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

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

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

--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",
"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.
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
"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",
"LatestMatchingVersion": {
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-
layer:2",
"Version": 2,
"CreatedDate": "2018-11-15T00:37:46.592+0000",
"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
},
"LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
"CreatedDate": "2018-11-15T00:37:46.592+0000",
"Version": 2,
"python3.6",
"python3.7",
78
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
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
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
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.
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

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

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

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.

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

--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
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": [
],
"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
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "EnforceOutOfVPC",
"Action": [
],
"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": [
],
"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": [
],
"Effect": "Deny",
"Resource": "*",
"Condition": {
"ForAnyValue:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
}
}
}
]
}
85
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": [
],
"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": [
],
"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": [
],
"Effect": "Allow",
"Resource": "*",
"Condition": {
"ForAllValues:StringEquals": {
"lambda:SecurityGroupIds": ["sg-1", "sg-2"]
86
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
Uso de los permisos de la función para autenticación
Para crear un proxy de base de datos

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
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.
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
• 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
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
91
Configuración de un sistema de
archivos y un punto de acceso

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

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

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

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

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
Type: AWS::EFS::FileSystem
Properties:
PerformanceMode: generalPurpose
MountTarget1:
Type: AWS::EFS::MountTarget
Properties:
FileSystemId:
Ref: FileSystem
SubnetId:
Ref: Subnet1
SecurityGroups:
- Ref: EfsSecurityGroup
MyFunctionWithEfs:
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).
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

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

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

{
"StatusCode": 200,
"LogResult":
}

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

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

3. En Designer (Diseñador), elija Add destination (Añadir destino).
105
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
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,
"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
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.

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

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.

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

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
• 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",
"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
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
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.
{
"requestContext": {
"requestId": "c9b8fa9f-5a7f-xmpl-af9c-0c604cde93a5",
"functionArn": "arn:aws:lambda:us-east-2:123456789012:function:myfunction",
"condition": "RetryAttemptsExhausted",
},
"statusCode": 200,
},
"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
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

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

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
Escalado de funciones
Example Configuración de funciones: conexión a una VPC
{
"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:

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
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
Leyenda
• 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
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
117
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
Control de errores
Leyenda
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.

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

this is output

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
122
Tutorial

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.

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);
}

3. Cree una función de Lambda con el comando create-function.
$ aws lambda create-function --function-name AndroidBackendLambdaFunction \

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

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

}
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
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
Código de muestra
• Node.js (p. 128)

• Java (p. 128)
Node.js
Example index.js

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

}
public String getLastName() {

return lastName;
}
public void setLastName(String lastName) {

}
public RequestClass(String firstName, String lastName) {

}
128
Código de muestra
public RequestClass() {
}
}
public static class ResponseClass {

String greetings;
public String getGreetings() {

return greetings;
}
public void setGreetings(String greetings) {

}
public ResponseClass(String 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
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

botocore-1.15.49
130

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

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
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
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
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\"}"
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
138
Crear una función

this is output
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.

• Trusted entity (Entidad de confianza) – Lambda.

• Role name (Nombre de rol): lambda-role.

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

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",
140
Crear una capa
"CodeSha256": "mv/xRv84LPCxdpcbKvmwuuFzwo7sLwUO1VxcUv3wKlM=",
"TracingConfig": {
},
"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,
}
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
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
{
"Layers": [
{
"Arn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:1",
"CodeSize": 584,
}
]
...
}
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
{
"CodeSize": 270,
"Layers": [
{
"Arn": "arn:aws:lambda:us-west-2:123456789012:layer:bash-runtime:7",
"CodeSize": 584,
}
]
...
}
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,
}
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
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
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
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

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

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
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
Requisitos previos
• Eliminar recursos (p. 155)
Requisitos previos

this is output
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

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

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

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
PrimaryKey:
Name: id
Type: String
ProvisionedThroughput:
ReadCapacityUnits: 1
WriteCapacityUnits: 1
helloFromLambdaFunction:
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
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
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

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

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

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

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

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.

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
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
API Gateway
Para agregar un punto de enlace público a la función Lambda

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
API Gateway
"requestContext": {
"resourcePath": "/",
"path": "/Prod/",
...
},
"headers": {
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,
"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,
}
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
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
<
{
"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)
• Tutorial: uso de AWS Lambda con Amazon API Gateway (p. 172)
• 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
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)
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
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
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
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.
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
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",
"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
Tutorial
Requisitos previos

this is output

AWS.

• 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
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.
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
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
*/
//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
Tutorial
};

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

--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.
{
"payload": {
}
}
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
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
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
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 \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/*/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":
\":\"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 \
--source-arn "arn:aws:execute-api:$REGION:$ACCOUNT:$API/prod/POST/DynamoDBManager"
{
"Statement": "{\"Sid\":\"apigateway-prod-2\",\"Effect\":\"Allow\",\"Principal\":
\":\"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
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)
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",
"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
Código de muestra
Example echo.json
{
"payload": {
}
}
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

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
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
*/
//console.log('Received event:', JSON.stringify(event, null, 2));
var operation = event.operation;
181
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':
break;
case 'ping':
callback(null, "pong");
break;
default:
callback('Unknown operation: ${operation}');
}
};
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
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))
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
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.
• Nombre – lambda-microservice.
• Rol – Crear un rol nuevo a partir de una o varias plantillas.
• 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:
{
"TableName": "MyTable"
}
}
3. Una vez introducido el texto anterior, elija Save and test.
184
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
Resources:
LambdaFunctionOverHttps:
Properties:
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
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"
},
{
"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",
"sourceIPAddress":"205.251.233.176",
"userAgent":"console.amazonaws.com",
"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
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:

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

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

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
"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"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"
},
{
"userIdentity": {
"type": "IAMUser",
"principalId": "A1B2C3D4E5F6G7EXAMPLE",
"arn": "arn:aws:iam::999999999999:user/myUserName",
"accountId": "999999999999",
"userName": "myUserName"
},
"eventTime": "2015-03-18T19:04:42Z",
"eventSource": "lambda.amazonaws.com",
"eventName": "DeleteFunction",
"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
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
Tutorial
Requisitos
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.
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.
1. Abra la página Roles de la consola de IAM.
191
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.
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
Tutorial
var s3 = new aws.S3();

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

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
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
Código de muestra
• Función Lambda: la función Lambda que desea que Amazon S3 invoque.
Para configurar notificaciones

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

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 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
});

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
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");
});
};
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
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",
"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",
"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

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
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
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/.
3. Elija el Proyecto.
4. Escriba canary en la barra de búsqueda. Elija proyecto lambda-canary y, a continuación, elija
Configure (Configurar).
• Nombre – lambda-canary.
198
Tutorial
• Rol – Crear un rol nuevo a partir de una o varias plantillas.

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

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.
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
Amazon SNS envía un email desde Canary <no-reply@sns.amazonaws.com>, 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

2. Elija lambda-canary.
4. Establezca expected en 404.
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
tutorial (p. 198). Copie el texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha
200
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.
Parameters:
NotificationEmail:
Type: String
Resources:
CheckWebsitePeriodically:
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'
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
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
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
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
Resources:
primer:
Properties:
Runtime: nodejs12.x
InlineCode: |
204
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
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
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": [
{
"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",
"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
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": {
"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": {
"secretAccessKey": "6CGtmAa3lzWtV7a...",
"sessionToken": "IQoJb3JpZ2luX2VjEA...",
"expirationTime": 1575493418000
}
}
}
}
208
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:

• 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
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
• 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
Tutorial
Requisitos previos

this is output
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

• 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
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(),
});
};
La plantilla de AWS SAM (p. 29) que define la aplicación.
Description: Outputs the time
Resources:
TimeFunction:
Properties:
Runtime: nodejs10.x
CodeUri: ./
Events:
MyTimeApi:
Type: Api
Properties:
Path: /TimeResource
Method: GET
212
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
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

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

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",
"identityId": "identityId",
"datasetRecords": {
"SampleKey2": {
"newValue": "newValue2",
215
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
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",
"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",
"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
"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)
• Plantilla de AWS SAM para una aplicación de DynamoDB (p. 230)

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:
218
Configuración de una secuencia como origen de eventos
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

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


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,
stream/2019-06-10T19:26:16.525",
"LastModified": 1560209851.963,
}
Configure otras opciones para personalizar el modo en que se procesan los lotes y especificar cuándo
deben descargarse los registros que no se pueden procesar. En el siguiente ejemplo, se actualiza la
asignación de un origen de eventos para enviar un registro de error a una cola de SQS después de dos
reintentos o si los registros tienen más de una hora de antigüedad.
$ aws lambda update-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \

--maximum-retry-attempts 2 --maximum-record-age-in-seconds 3600
--destination-config '{"OnFailure": {"Destination": "arn:aws:sqs:us-
east-2:123456789012:dlq"}}'
{
"UUID": "f89f8514-cdd9-4602-9e1f-01a5b77d449b",
"BatchSize": 100,
220
Control de errores
stream/2019-06-10T19:26:16.525",
"LastModified": 1573243620.0,
"LastProcessingResult": "PROBLEM: Function call failed",
"State": "Updating",
}
La configuración actualizada se aplica de forma asincrónica y no se refleja en la salida hasta que se

completa el proceso. Utilice el comando get-event-source-mapping para ver el estado actual.
$ aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b

{
"BatchSize": 100,
stream/2019-06-10T19:26:16.525",
"State": "Enabled",
"OnFailure": {
"Destination": "arn:aws:sqs:us-east-2:123456789012:dlq"
}
},
}
Para procesar varios lotes simultáneamente, utilice la opción --parallelization-factor.
$ aws lambda update-event-source-mapping --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 \

--parallelization-factor 5
Control de errores
La asignación del origen de eventos que lee los registros de la secuencia de DynamoDB invoca la función
de forma sincrónica y reintenta la operación si se producen errores. Si la función se ve limitada o el servicio
de Lambda devuelve un error sin invocar la función, Lambda vuelve a intentarlo hasta que el registro expira
o supera la antigüedad máxima establecida en la asignación del origen de eventos.
Si la función recibe los registros pero devuelve un error, Lambda lo vuelve a intentar hasta que vencen los
registros del lote, se supera la antigüedad máxima o se alcanza la cuota de reintentos especificada. En el
caso de los errores de funciones, también puede configurar la asignación del origen de eventos para que
divida en dos los lotes que presentan errores. Al intentarlo con lotes más pequeños, se aíslan los registros
erróneos y se solucionan problemas relacionadas con el tiempo de espera. Los lotes divididos no se tienen
en cuenta para calcular la cuota de reintentos.
Si las medidas de administración de errores no funcionan, Lambda descarta los registros y sigue
procesando los lotes de la secuencia. Con la configuración predeterminada, esto significa que un registro
221
Métricas de Amazon CloudWatch
erróneo puede bloquear el procesamiento de la partición afectada durante un máximo de one day. Para
evitar esto, configure la asignación del origen de eventos de la función con un número razonable de
reintentos y una antigüedad de registro máxima que se ajuste a su caso de uso.
Para mantener un registro de los lotes descartados, configure un destino de evento fallido. Lambda enviará
un documento a la cola o al tema de destino con información sobre el lote.
Para configurar un destino para registros de eventos con errores

4. En Source (Origen), elija Stream invocation (Invocación por secuencias).
5. En Stream (Secuencia), elija una secuencia que esté asignada a la función.
El siguiente ejemplo muestra un registro de invocación para un flujo de DynamoDB.
{
"requestContext": {
"requestId": "316aa6d0-8154-xmpl-9af7-85d5f4a6bc81",
},
"statusCode": 200,
},
"version": "1.0",
"timestamp": "2019-11-14T00:13:49.717Z",
"DDBStreamBatchInfo": {
"shardId": "shardId-00000001573689847184-864758bb",
"approximateArrivalOfFirstRecord": "2019-11-14T00:13:19Z",
"approximateArrivalOfLastRecord": "2019-11-14T00:13:19Z",
"batchSize": 1,
"streamArn": "arn:aws:dynamodb:us-east-2:123456789012:table/mytable/
stream/2019-11-14T00:04:06.388"
}
}
Puede utilizar esta información para recuperar los registros afectados de la secuencia y solucionar los
problemas. Los registros reales no están incluidos, por lo que debe procesar este registro y recuperarlos
de la secuencia antes de que venzan y se pierdan.

Lambda emite la métrica IteratorAge cuando la función termina de procesar un lote de registros.
La métrica indica la antigüedad del último registro del lote cuando acabo el proceso. Si la función está
222
Tutorial
procesando nuevos eventos, puede utilizar la antigüedad del iterador para estimar la latencia entre el
momento en que se añade un registro y el momento en que la función lo procesa.
Una tendencia ascendente en la antigüedad del iterador puede indicar problemas con la función. Para
obtener más información, consulte Trabajar con métricas de funciones de AWS Lambda (p. 464).
Tutorial: Uso de AWS Lambda con flujos de Amazon

DynamoDB
En este tutorial, se crea una función de Lambda para consumir eventos de un flujo de Amazon DynamoDB.
Requisitos previos

this is output

AWS.


• Permisos – AWSLambdaDynamoDBExecutionRole.
• Role name (Nombre de rol): lambda-dynamodb-role.
El AWSLambdaDynamoDBExecutionRole (Rol de ejecución Dynamo DB de AWS Lambda) tiene los

permisos que la función necesita para leer elementos desde DynamoDB y escribir registros al CloudWatch
Logs.
A continuación se muestra código de ejemplo que recibe un evento de DynamoDB como entrada y procesa
los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
entrada en CloudWatch Logs.
223
Tutorial
Note
Example index.js

console.log(JSON.stringify(event, null, 2));
event.Records.forEach(function(record) {
console.log(record.eventID);
console.log(record.eventName);
console.log('DynamoDB Record: %j', record.dynamodb);
});
callback(null, "message");
};

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

--role arn:aws:iam::123456789012:role/lambda-dynamodb-role

En este paso, invocará la función de Lambda manualmente mediante el comando invoke de la CLI de
AWS Lambda y el siguiente evento de muestra de DynamoDB.
Example input.txt
{
"Records":[
{
"eventID":"1",
"eventName":"INSERT",
"eventSource":"aws:dynamodb",
"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"NewImage":{
"Message":{
"S":"New item!"
},
"Id":{
224
Tutorial
"N":"101"
}
},
"SequenceNumber":"111",
"SizeBytes":26,
"StreamViewType":"NEW_AND_OLD_IMAGES"
},
"eventSourceARN":"stream-ARN"
},
{
"eventID":"2",
"eventName":"MODIFY",
"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"NewImage":{
"Message":{
"S":"This item has changed"
},
"Id":{
"N":"101"
}
},
"OldImage":{
"Message":{
"S":"New item!"
},
"Id":{
"N":"101"
}
},
"SizeBytes":59,
},
},
{
"eventID":"3",
"eventName":"REMOVE",
"dynamodb":{
"Keys":{
"Id":{
"N":"101"
}
},
"OldImage":{
"Message":{
"S":"This item has changed"
},
"Id":{
"N":"101"
}
},
"SizeBytes":38,
225
Tutorial
},
}
]
}
Ejecute el siguiente comando invoke.
$ aws lambda invoke --function-name ProcessDynamoDBRecords --payload file://input.txt

outputfile.txt
La función devuelve la cadena message en el cuerpo de la respuesta.
Verifique la salida en el archivo outputfile.txt.
Crear una tabla de DynamoDB con un flujo habilitado

Crear una tabla de Amazon DynamoDB con un flujo habilitado.
Para crear una tabla de DynamoDB

2. Seleccione Create table.
3. Cree una tabla con la siguiente configuración:
• Nombre de la tabla – lambda-dynamodb-stream

• Primary key (Clave principal) – id (cadena)
Habilitar secuencias

2. Elija Tables (Tablas).
3. Elija la tabla lambda-dynamodb-stream (Flujo de dynamodb lambda).
4. En la pestaña Información general, elija Administrar flujo.
5. Elija Enable.
Anote el ARN del flujo. Lo necesitará en el siguiente paso al asociar el flujo a la función de Lambda. Para
obtener más información acerca de cómo habilitar flujos, consulte Captura de la actividad de las tablas con
flujos de DynamoDB.
Añadir un origen de eventos en AWS Lambda

Crear un mapeo de origen de eventos en AWS Lambda. Este mapeo de origen de eventos asocia el flujo
de DynamoDB a la función de Lambda. Una vez creado este mapeo de origen de eventos, AWS Lambda
comienza a sondear el flujo.
Ejecute el comando siguiente AWS CLI create-event-source-mapping. Una vez ejecutado el

comando, anote el UUID. Necesitará este UUID para hacer referencia al mapeo de origen de eventos en
los comandos, por ejemplo, al eliminar el mapeo de origen de eventos.
$ aws lambda create-event-source-mapping --function-name ProcessDynamoDBRecords \
226
Código de muestra
--batch-size 100 --starting-position LATEST --event-source DynamoDB-stream-arn
Esto crea un mapeo entre el flujo de DynamoDB especificado y la función de Lambda. Puede asociar
un flujo de DynamoDB a varias funciones de Lambda, así como asociar la misma función de Lambda a
varios flujos. Sin embargo, las funciones de Lambda compartirán el desempeño de lectura para el flujo que
comparten.
Para obtener la lista de mapeos de orígenes de eventos, ejecute el siguiente comando.
$ aws lambda list-event-source-mappings
La lista devuelve todos los mapeos de orígenes de eventos creados, y para cada uno de ellos muestra
el LastProcessingResult, entre otras cosas. Este campo se utiliza para proporcionar un mensaje
informativo en caso de que surja algún problema. Los valores como No records processed (indica
que AWS Lambda no ha comenzado el sondeo o que no hay registros en el flujo) y OK (indica que AWS
Lambda ha leído correctamente los registros del flujo y ha invocado la función de Lambda) indican que no
hay ningún problema. Si hay algún problema, recibirá un mensaje de error.
Si tiene muchos mapeos de origen de eventos, use la función nombrar parámetro para reducir los
resultados.
$ aws lambda list-event-source-mappings --function-name ProcessDynamoDBRecords
Prueba de la configuración
Probar la experiencia integral. A medida que se actualiza la tabla, DynamoDB escribe los registros de
eventos en el flujo. AWS Lambda sondea el flujo, detecta nuevos registros en él y ejecuta la función de
Lambda en nombre del usuario pasando eventos a esta.
1. En la consola de DynamoDB, añada, actualice y elimine elementos de la tabla. DynamoDB escribe

registros de estas acciones en el flujo.
2. AWS Lambda sondea el flujo y, cuando detecta actualizaciones en este, invoca la función de Lambda
pasando los datos de eventos que encuentra en el flujo.
3. La función ejecuta y crea registros en Amazon CloudWatch. Puede verificar los registros reportados en
la consola de Amazon CloudWatch.

Temas
• Node.js (p. 227)
• Java 11 (p. 228)
• C# (p. 229)
• Python 3 (p. 229)
• Go (p. 230)
Node.js
En el siguiente ejemplo, se procesan los mensajes de DynamoDB, y registra su contenido.
227
Código de muestra
Example ProcessDynamoDBStream.js
exports.lambda_handler = function(event, context, callback) {

console.log(JSON.stringify(event, null, 2));
console.log(record.eventID);
console.log(record.eventName);
console.log('DynamoDB Record: %j', record.dynamodb);
});
};
Java 11
El siguiente ejemplo procesa mensajes desde DynamoDB y registra sus contenidos. handleRequest es
el controlador que AWS Lambda invoca y proporciona datos de evento. Este controlador utiliza la clase
DynamodbEvent predefinida, que se define en la biblioteca aws-lambda-java-events.
Example DDBEventProcessor.java
package example;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent.DynamodbStreamRecord;
public class DDBEventProcessor implements

RequestHandler<DynamodbEvent, String> {
public String handleRequest(DynamodbEvent ddbEvent, Context context) {

for (DynamodbStreamRecord record : ddbEvent.getRecords()){
System.out.println(record.getEventID());
System.out.println(record.getEventName());
System.out.println(record.getDynamodb().toString());
}
return "Successfully processed " + ddbEvent.getRecords().size() + " records.";
}
}
Si el controlador vuelve normalmente sin excepciones, Lambda considera que el lote de registros de
entrada se ha procesado correctamente y empieza a leer nuevos registros en el flujo. Si el controlador
genera una excepción, Lambda considera que el lote de registros de entrada no se ha procesado e invoca
de nuevo la función con el mismo lote de registros.
Dependencias.
• aws-lambda-java-events
Java (p. 386).
228
Código de muestra
C#
El siguiente ejemplo procesa mensajes desde DynamoDB y registra sus contenidos.
ProcessDynamoEvent es el controlador que AWS Lambda invoca y proporciona datos de evento.
Este controlador utiliza la clase DynamoDbEvent predefinida, que se define en la biblioteca
Amazon.Lambda.DynamoDBEvents.
Example ProcessingDynamoDBStreams.cs
using System;
using System.IO;
using System.Text;
using Amazon.Lambda.Core;
using Amazon.Lambda.DynamoDBEvents;
using Amazon.Lambda.Serialization.Json;
namespace DynamoDBStreams
{
public class DdbSample
{
private static readonly JsonSerializer _jsonSerializer = new JsonSerializer();
public void ProcessDynamoEvent(DynamoDBEvent dynamoEvent)

{
Console.WriteLine($"Beginning to process {dynamoEvent.Records.Count}
records...");
foreach (var record in dynamoEvent.Records)

{
Console.WriteLine($"Event ID: {record.EventID}");
Console.WriteLine($"Event Name: {record.EventName}");
string streamRecordJson = SerializeObject(record.Dynamodb);

Console.WriteLine($"DynamoDB Record:");
Console.WriteLine(streamRecordJson);
}
Console.WriteLine("Stream processing complete.");

}
private string SerializeObject(object streamRecord)

{
using (var ms = new MemoryStream())
{
_jsonSerializer.Serialize(streamRecord, ms);
return Encoding.UTF8.GetString(ms.ToArray());
}
}
}
}
Reemplace Program.cs en un proyecto .NET Core con el ejemplo anterior. Para obtener instrucciones,
consulte AWS Lambda Paquete de implementación en C# (p. 433).
Python 3
Example ProcessDynamoDBStream.py
229
def lambda_handler(event, context):

for record in event['Records']:
print(record['eventID'])
print(record['eventName'])
print('Successfully processed %s records.' % str(len(event['Records'])))
Go
Example
import (
"strings"
)
func handleRequest(ctx context.Context, e events.DynamoDBEvent) {
for _, record := range e.Records {

fmt.Printf("Processing request data for event ID %s, type %s.\n", record.EventID,
record.EventName)
// Print new values for attributes of type String

for name, value := range record.Change.NewImage {
if value.DataType() == events.DataTypeString {
fmt.Printf("Attribute name: %s, value: %s\n", name, value.String())
}
}
}
}
Plantilla de AWS SAM para una aplicación de

DynamoDB
A continuación, hay una plantilla AWS SAM de muestra para la aplicación del tutorial (p. 223). Copie el
texto siguiente en un archivo .yaml y guárdelo junto al paquete ZIP que ha creado anteriormente. Tenga en
cuenta que los valores de los parámetros Handler y Runtime deben coincidir con los que utilizó cuando
creó la función en la sección anterior.
Resources:
230
EC2
ProcessDynamoDBStream:
Properties:
Handler: handler
Runtime: runtime
Policies: AWSLambdaDynamoDBExecutionRole
Events:
Stream:
Type: DynamoDB
Properties:
Stream: !GetAtt DynamoDBTable.StreamArn
BatchSize: 100
StartingPosition: TRIM_HORIZON
DynamoDBTable:
Type: AWS::DynamoDB::Table
Properties:
AttributeDefinitions:
- AttributeName: id
AttributeType: S
KeySchema:
- AttributeName: id
KeyType: HASH
ProvisionedThroughput:
ReadCapacityUnits: 5
WriteCapacityUnits: 5
StreamSpecification:
StreamViewType: NEW_IMAGE
Uso de AWS Lambda con Amazon EC2

Puede utilizar AWS Lambda para procesar eventos del ciclo de vida desde Amazon Elastic Compute
Cloud y administrar recursos de Amazon EC2. Amazon EC2 envía eventos a Amazon CloudWatch
Events para eventos del ciclo de vida, como cuando una instancia cambia de estado, cuando se completa
una instantánea de volumen de Amazon Elastic Block Store o cuando se programa que se termine una
instancia de spot. Configure Eventos de CloudWatch para reenviar esos eventos a una función de Lambda
para su procesamiento.
Eventos de CloudWatch invoca su función de Lambda de forma asíncrona con el documento de evento de
Amazon EC2.
Example Ciclo de vida de la instancia
{
"version": "0",
"id": "b6ba298a-7732-2226-xmpl-976312c1a050",
"detail-type": "EC2 Instance State-change Notification",
"source": "aws.ec2",
"account": "123456798012",
"time": "2019-10-02T17:59:30Z",
"resources": [
"arn:aws:ec2:us-east-2:123456798012:instance/i-0c314xmplcd5b8173"
],
"detail": {
231
Permisos
"instance-id": "i-0c314xmplcd5b8173",
"state": "running"
}
}
Para obtener información detallada sobre la configuración de eventos en Eventos de CloudWatch, consulte
Uso de AWS Lambda con Amazon CloudWatch Events (p. 196). Para ver una función de ejemplo que
procesa las notificaciones de instantáneas de Amazon EBS, consulte Amazon CloudWatch Events para
Amazon EBS en Guía del usuario de Amazon EC2 para instancias de Linux.
También puede utilizar AWS SDK para administrar instancias y otros recursos con la API de Amazon EC2.
Para ver un tutorial con una aplicación de ejemplo en C#, consulte Tutorial: Uso de AWS SDK para .NET
para administrar instancias de spot de Amazon EC2 (p. 232).
Permisos
Para procesar eventos del ciclo de vida desde Amazon EC2, Eventos de CloudWatch necesita permiso
para invocar su función. Este permiso proviene de la política basada en recursos (p. 37) de la función. Si
utiliza la consola de Eventos de CloudWatch para configurar un desencadenador de eventos, la consola
actualiza la directiva basada en recursos en su nombre. De lo contrario, agregue una declaración como la
siguiente:
Example Instrucción de una política basada en recursos para notificaciones del ciclo de vida de
Amazon EC2
{
"Sid": "ec2-events",
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "lambda:InvokeFunction",
"Resource": "arn:aws:lambda:us-east-2:12456789012:function:my-function",
"Condition": {
"ArnLike": {
"AWS:SourceArn": "arn:aws:events:us-east-2:12456789012:rule/*"
}
}
}
Para agregar una instrucción, utilice el comando de la AWS CLI add-permission.
aws lambda add-permission --action lambda:InvokeFunction --statement-id ec2-events \

--principal events.amazonaws.com --function-name my-function --source-arn
'arn:aws:events:us-east-2:12456789012:rule/*'
Si la función utiliza el SDK de AWS para administrar recursos de Amazon EC2, agregue permisos de
Amazon EC2 al rol de ejecución (p. 33) de la función.
Tutorial: Uso de AWS SDK para .NET para administrar

instancias de spot de Amazon EC2
Puede usar AWS SDK para .NET para administrar instancias de spot de Amazon EC2 con código C#. El
SDK le permite utilizar la API de Amazon EC2 para crear solicitudes de instancias de spot, determinar
cuándo se cumple la solicitud, eliminar solicitudes e identificar las instancias creadas.
232
Tutorial: Instancias de spot
Este tutorial proporciona código que realiza estas tareas y una aplicación de ejemplo que puede ejecutar
localmente o en AWS. Incluye un proyecto de ejemplo que puede implementar en el tiempo de ejecución
de .NET Core 2.1 de AWS Lambda.
Para obtener más información sobre el uso de instancias de spot y prácticas recomendadas, consulte
Instancias de spot en la guía de usuario de Amazon EC2.
Requisitos previos

this is output
233
Este tutorial utiliza código del repositorio de GitHub de la guía para desarrolladores. El repositorio también
contiene scripts auxiliares y archivos de configuración necesarios para seguir sus procedimientos. Clone el
repositorio en github.com/awsdocs/aws-lambda-developer-guide.
Para usar el código de muestra necesita las siguientes herramientas:
• AWS CLI: para implementar la aplicación de muestra en AWS, instale la AWS CLI. La AWS CLI también
proporciona credenciales al código de muestra cuando se ejecuta localmente.
• CLI de .NET Core: para ejecutar y probar el código localmente, instale .NET Core SDK 2.1.
• Herramienta global de .NET Core de Lambda: para crear el paquete de implementación para Lambda,
instale la Herramienta global de .NET Core con la CLI de .NET Core.
$ dotnet tool install -g Amazon.Lambda.Tools
El código de este tutorial administra las solicitudes de spot que lanzan instancias Amazon EC2. Para
ejecutar el código localmente, necesita credenciales de SDK con permiso para usar las siguientes API.
• ec2:RequestSpotInstance
• ec2:GetSpotRequestState
• ec2:CancelSpotRequest
• ec2:TerminateInstances
Para ejecutar la aplicación de ejemplo en AWS, necesita permiso para usar Lambda (p. 33) y los siguientes
servicios.
• AWS CloudFormation (precios)

• Amazon Elastic Compute Cloud (precios)
Se aplican cargos estándar por cada servicio.
Revise el código
Localice el proyecto de ejemplo en el repositorio de guías en sample-apps/ec2-spot. Este directorio
contiene código de función de Lambda, pruebas, archivos de proyecto, scripts y una plantilla de AWS
CloudFormation.
La clase Function incluye un método FunctionHandler que llama a otros métodos para crear
solicitudes de spot, comprobar su estado y limpiar. Crea un cliente Amazon EC2 con el AWS SDK
para .NET en un constructor estático para permitir que se use en toda la clase.
Example Function.cs – FunctionHandler
using Amazon.EC2;
...
public class Function
{
private static AmazonEC2Client ec2Client;
static Function() {
AWSSDKHandler.RegisterXRayForAllServices();
ec2Client = new AmazonEC2Client();
}
234
public async Task<string> FunctionHandler(Dictionary<string, string> input,

ILambdaContext context)
{
// More AMI IDs: aws.amazon.com/amazon-linux-2/release-notes/
// us-east-2 HVM EBS-Backed 64-bit Amazon Linux 2
string ami = "ami-09d9edae5eb90d556";
string sg = "default";
InstanceType type = InstanceType.T3aNano;
string price = "0.003";
int count = 1;
var requestSpotInstances = await RequestSpotInstance(ami, sg, type, price,
count);
var spotRequestId =
requestSpotInstances.SpotInstanceRequests[0].SpotInstanceRequestId;
El método RequestSpotInstance crea una solicitud de instancia de spot.
Example Function.cs – RequestSpotInstance
using Amazon;
using Amazon.Util;
using Amazon.EC2;
using Amazon.EC2.Model;
...
public async Task<RequestSpotInstancesResponse> RequestSpotInstance(
string amiId,
string securityGroupName,
InstanceType instanceType,
string spotPrice,
int instanceCount)
{
var request = new RequestSpotInstancesRequest();
var launchSpecification = new LaunchSpecification();

launchSpecification.ImageId = amiId;
launchSpecification.InstanceType = instanceType;
launchSpecification.SecurityGroups.Add(securityGroupName);
request.SpotPrice = spotPrice;
request.InstanceCount = instanceCount;
request.LaunchSpecification = launchSpecification;
RequestSpotInstancesResponse response = await

ec2Client.RequestSpotInstancesAsync(request);
return response;
}
...
A continuación, debemos esperar hasta que la solicitud de spot alcance el estado Active antes
de continuar con el último paso. Para determinar el estado de la solicitud de spot, utilice el método
DescribeSpotInstanceRequests para obtener el estado del ID de solicitud de spot que deseamos
monitorizar.
public async Task<SpotInstanceRequest> GetSpotRequest(string spotRequestId)

{
var request = new DescribeSpotInstanceRequestsRequest();
request.SpotInstanceRequestIds.Add(spotRequestId);
var describeResponse = await ec2Client.DescribeSpotInstanceRequestsAsync(request);
return describeResponse.SpotInstanceRequests[0];
235
El paso final consiste en limpiar las instancias y solicitudes. Es importante tanto para cancelar cualquier
solicitud pendiente como para terminar cualquier instancia. Las instancias no terminarán con solo
cancelarse las solicitudes, lo que significa que se le seguirá cobrando por ellas. Si termina las instancias,
es posible que se cancelen las solicitudes de spot, pero hay algunos escenarios (por ejemplo, si usa
solicitudes persistentes), donde terminar las instancias no es suficiente para evitar que la solicitud vuelva
a atenderse. Por lo tanto, se recomienda tanto cancelar cualquier solicitud activa como terminar cualquier
instancia en ejecución.
Puede usar el método CancelSpotInstanceRequests para cancelar una solicitud de spot. En el siguiente
ejemplo se muestra cómo cancelar una solicitud de subasta.
public async Task CancelSpotRequest(string spotRequestId)

{
Console.WriteLine("Canceling request " + spotRequestId);
var cancelRequest = new CancelSpotInstanceRequestsRequest();
cancelRequest.SpotInstanceRequestIds.Add(spotRequestId);
await ec2Client.CancelSpotInstanceRequestsAsync(cancelRequest);
}
Puede usar el método TerminateInstances para terminar una instancia.
public async Task TerminateSpotInstance(string instanceId)

{
Console.WriteLine("Terminating instance " + instanceId);
var terminateRequest = new TerminateInstancesRequest();
terminateRequest.InstanceIds = new List<string>() { instanceId };
try
{
var terminateResponse = await ec2Client.TerminateInstancesAsync(terminateRequest);
}
catch (AmazonEC2Exception ex)
{
// Check the ErrorCode to see if the instance does not exist.
if ("InvalidInstanceID.NotFound" == ex.ErrorCode)
{
Console.WriteLine("Instance {0} does not exist.", instanceId);
}
else
{
// The exception was thrown for another reason, so re-throw the exception.
throw;
}
}
}
Ejecución del código localmente

Ejecute el código en su máquina local para crear una solicitud de instancia de spot. Una vez cumplida la
solicitud, el código elimina la solicitud y termina la instancia.
Para ejecutar el código de la aplicación
1. Vaya al directorio ec2Spot.Tests.
$ cd test/ec2Spot.Tests
236
2. Utilice la CLI de .NET para ejecutar las pruebas de unidad del proyecto.
test/ec2Spot.Tests$ dotnet test

Starting test execution, please wait...
sir-x5tgs5ij
open
open
open
open
open
active
Canceling request sir-x5tgs5ij
Terminating instance i-0b3fdff0e12e0897e
Complete
Test Run Successful.

Total tests: 1
Passed: 1
Total time: 7.6060 Seconds
La prueba de unidad invoca el método FunctionHandler para crear una solicitud de instancia de spot,
supervisarla y limpiarla. Se implementa en el marco de pruebas XUnit.net.
Implementación de la aplicación
Ejecute el código en Lambda como punto de partida para crear una aplicación sin servidor.
Para implementar y probar la aplicación
1. Establezca su región en us-east-2.
$ export AWS_DEFAULT_REGION=us-east-2
2. Cree un bucket para artefactos de implementación.
$ ./create-bucket.sh
make_bucket: lambda-artifacts-63d5cbbf18fa5ecc
3. Cree un paquete de implementación e implemente la aplicación.
$ ./deploy.sh
Amazon Lambda Tools for .NET Core applications (3.3.0)
Project Home: https://github.com/aws/aws-extensions-for-dotnet-cli, https://github.com/
aws/aws-lambda-dotnet
Executing publish command

...
Created publish archive (ec2spot.zip)
Lambda project successfully packaged: ec2spot.zip
Uploading to ebd38e401cedd7d676d05d22b76f0209 1305107 / 1305107.0 (100.00%)
Successfully packaged artifacts and wrote output template to file out.yaml.
Execute the following command to deploy the packaged template
aws cloudformation deploy --template-file out.yaml --stack-name <YOUR STACK NAME>
Waiting for changeset to be created..

Waiting for stack create/update to complete
Successfully created/updated stack - ec2-spot
237
5. En Resources (Recursos), elija function (función).

6. Elija Test (Prueba) y cree un evento de prueba a partir de la plantilla predeterminada.
7. Elija Test (Probar) de nuevo para invocar la función.
Ver los registros y la información de rastreo para ver el ID de solicitud de spot y la secuencia de llamadas a
Amazon EC2.
Para ver el mapa de servicio, abra la página Service map (Mapa de servicio) en la consola de X-Ray.
238
Elija un nodo en el mapa de servicio y, a continuación, elija View traces (Ver seguimientos) para ver una
lista de rastreos. Elija un rastreo de la lista para ver la línea de tiempo de las llamadas que efectuó la
función a Amazon EC2.
239
Eliminar recursos
El código proporcionado en este tutorial está diseñado para crear y eliminar solicitudes de instancias de
spot y para terminar las instancias que inician. Sin embargo, si se produce un error, es posible que las
240
ElastiCache
solicitudes e instancias no se limpien automáticamente. Visualice las solicitudes e instancias puntuales en

la consola de Amazon EC2.
Para confirmar que los recursos de Amazon EC2 se limpian
1. Abra la página Spot Requests (Solicitudes de spot) en la consola de Amazon EC2.

2. Compruebe que el estado de las solicitudes sea Cancelled (Cancelado).
3. Seleccione el ID de instancia en la columna Capacity (Capacidad) para ver la instancia.
4. Compruebe que el estado de las instancias sea Terminated (Terminado) o Shutting down (Cierre).
Para limpiar la función de ejemplo y los recursos de soporte, elimine su pila de AWS CloudFormation y el
bucket de artefactos que creó.
$ ./cleanup.sh
Delete deployment artifacts and bucket (lambda-artifacts-63d5cbbf18fa5ecc)?y
delete: s3://lambda-artifacts-63d5cbbf18fa5ecc/ebd38e401cedd7d676d05d22b76f0209
remove_bucket: lambda-artifacts-63d5cbbf18fa5ecc
El grupo de registro de la función no se elimina automáticamente. Puede eliminarlo en la consola

de CloudWatch Logs. Los rastreos en X-Ray caducan después de unas semanas y se eliminan
automáticamente.
Tutorial: Configuración de una función de Lambda

para obtener acceso a Amazon ElastiCache en una
Amazon VPC
• Crar un clúster de Amazon ElastiCache en su Amazon Virtual Private Cloud predeterminada. Para
obtener más información acerca de Amazon ElastiCache, consulte Amazon ElastiCache.
• Crear una función de Lambda para obtener acceso al clúster de ElastiCache. Al crear la función de
Lambda debe proporcionar los ID de subred de Amazon VPC, así como un grupo de seguridad de VPC
para que la función de Lambda pueda obtener acceso a los recursos de la VPC. En este tutorial, con
fines ilustrativos, la función de Lambda genera un UUID, lo escribe en la caché y lo recupera de esta.
• Invoque la función de Lambda manualmente y verifique que ha tenido acceso al clúster de ElastiCache
de la VPC.
Para obtener más información sobre el uso de Lambda con Amazon VPC, consulte Configuración de una
función de Lambda para obtener acceso a los recursos de una VPC (p. 81).
Requisitos previos
241

this is output

AWS.


• Permissions (Permisos) – AWSLambdaVPCAccessExecutionRole.
• Role name (Nombre de rol): lambda-vpc-role.
El AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para administrar las

conexiones de red a una VPC.
Creación de un clúster de ElastiCache

Cree un clúster de ElastiCache en su VPC predeterminada.
1. Ejecute el siguiente comando de la AWS CLI; para crear un clúster de Memcached.
$ aws elasticache create-cache-cluster --cache-cluster-id ClusterForLambdaTest \

--cache-node-type cache.m3.medium --engine memcached --num-cache-nodes 1 \
--security-group-ids sg-0897d5f549934c2fb
Puede buscar el grupo de seguridad de VPC predeterminado en la consola de VPC en Security

Groups. La función de Lambda de ejemplo añadirá y recuperará un elemento de este clúster.
2. Anote el punto de enlace de configuración para el clúster de caché que ha lanzado. Puede obtenerlo
de la consola de Amazon ElastiCache. Especificará este valor en el código de la función de Lambda
en la siguiente sección.
Creación de un paquete de implementación

El siguiente ejemplo de código de Python lee y escribe un elemento en el clúster de ElastiCache.
Example app.py

import time
import uuid
import sys
import socket
242
Creación de la función de Lambda
import elasticache_auto_discovery
from pymemcache.client.hash import HashClient
#elasticache settings
elasticache_config_endpoint = "your-elasticache-cluster-endpoint:port"
nodes = elasticache_auto_discovery.discover(elasticache_config_endpoint)
nodes = map(lambda x: (x[1], int(x[2])), nodes)
memcache_client = HashClient(nodes)

"""
This function puts into memcache and get from it.
Memcache is hosted using elasticache
"""
#Create a random UUID... this will be the sample element we add to the cache.
uuid_inserted = uuid.uuid4().hex
#Put the UUID to the cache.
memcache_client.set('uuid', uuid_inserted)
#Get item (UUID) from the cache.
uuid_obtained = memcache_client.get('uuid')
if uuid_obtained.decode("utf-8") == uuid_inserted:
# this print should go to the CloudWatch Logs and Lambda console.
print ("Success: Fetched value %s from memcache" %(uuid_inserted))
else:
raise Exception("Value is not the same as we put :(. Expected %s got %s"
%(uuid_inserted, uuid_obtained))
return "Fetched value from memcache: " + uuid_obtained.decode("utf-8")
Dependencias.
• pymemcache – El código de función de Lambda utiliza esta biblioteca para crear un HashClient objeto
para enviar y recibir elementos de un memcache.
• elasticache-auto-discovery – La función de Lambda usa esta biblioteca para recibir los nodos del clúster
Amazon ElastiCache.
Instale dependencias con Pip y cree un paquete de implementación. Para obtener instrucciones, consulte
Paquete de implementación de AWS Lambda en Python (p. 352).

Cree la función de Lambda con el comando create-function.
$ aws lambda create-function --function-name AccessMemCache --timeout 30 --memory-size 1024

\
--zip-file fileb://function.zip --handler app.handler --runtime python3.8 \
--role arn:aws:iam::123456789012:role/lambda-vpc-role \
--vpc-config SubnetIds=subnet-0532bb6758ce7c71f,subnet-
d6b7fda068036e11f,SecurityGroupIds=sg-0897d5f549934c2fb
Puede encontrar los ID de subred y el ID del grupo de seguridad predeterminado de la VPC en la consola
de VPC.

En este paso, invocará la función de Lambda manualmente utilizando el comando invoke. Cuando la
función de Lambda se ejecuta, genera un UUID y lo escribe en el clúster de ElastiCache especificado en el
código de la función de Lambda. A continuación, la función de Lambda recupera el elemento de la caché.
243
Elastic Load Balancing
1. Invoque la función de Lambda con el comando invoke.
$ aws lambda invoke --function-name AccessMemCache output.txt
2. Compruebe que la función de Lambda se ha ejecutado correctamente del modo siguiente:
• Revise el archivo output.txt.

• Revise los resultados en la consola de AWS Lambda.
• Verifique los resultados en CloudWatch Logs.
Ahora que ha creado una función de Lambda que tiene acceso a un clúster de ElastiCache en la VPC,
puede hacer que la función se invoque en respuesta a eventos. Para obtener información acerca de la
configuración de orígenes de eventos y ver ejemplos, consulte Utilización de AWS Lambda con otros
servicios (p. 163).
Uso de AWS Lambda con un Balanceador de carga

de aplicaciones
Puede utilizar funciones de Lambda para procesar solicitudes desde un Balanceador de carga de
aplicaciones. Elastic Load Balancing admite funciones de Lambda como destinos de un Balanceador de
carga de aplicaciones. Utilice reglas de balanceador de carga para direccionar solicitudes HTTP a una
función según la ruta o los valores de encabezado. Procese la solicitud y devuelva una respuesta HTTP
desde de su función de Lambda.
Elastic Load Balancing invoca la función de Lambda de forma sincrónica con un evento que contiene el
cuerpo de la solicitud y metadatos.
Example Evento de solicitud de Balanceador de carga de aplicaciones
{
"requestContext": {
"elb": {
"targetGroupArn": "arn:aws:elasticloadbalancing:us-
east-2:123456789012:targetgroup/lambda-279XGJDqGZ5rsrHC2Fjr/49e9d65c45c6791a"
}
},
"path": "/lambda",
"query": "1234ABCD"
},
"headers": {
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,
"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"
},
244
EFS
"body": "",
}
Su función procesa el evento y devuelve un documento de respuesta al balanceador de carga en JSON.

Elastic Load Balancing convierte el documento en una respuesta HTTP de éxito o error y lo devuelve al
usuario.
Example formato del documento de respuesta
{
"statusCode": 200,
"statusDescription": "200 OK",
"isBase64Encoded": False,
"headers": {
"Content-Type": "text/html"
},
"body": "<h1>Hello from Lambda!</h1>"
}
Para configurar Balanceador de carga de aplicaciones como desencadenador de funciones, conceda

a Elastic Load Balancing permiso para ejecutar la función, cree un grupo de destino que direccione las
solicitudes a la función y añada una regla al balanceador de carga para enviar las solicitudes al grupo de
destino.
Utilice el comando add-permission para añadir una instrucción de permiso a la política basada en
recursos de la función.
$ aws lambda add-permission --function-name alb-function \

--statement-id load-balancer --action "lambda:InvokeFunction" \
--principal elasticloadbalancing.amazonaws.com
{
"Statement": "{\"Sid\":\"load-balancer\",\"Effect\":\"Allow\",\"Principal\":{\"Service
\":\"elasticloadbalancing.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource
\":\"arn:aws:lambda:us-west-2:123456789012:function:alb-function\"}"
}
Para ver instrucciones sobre cómo configurar el agente de escucha de Balanceador de carga de
aplicaciones, consulte la sección sobre funciones de Lambda como destino en la Guía del usuario de
Application Load Balancers.
Uso de Amazon EFS con Lambda

Lambda se integra con Amazon Elastic File System (Amazon EFS) para que el acceso seguro y
compartido al sistema de archivos para las aplicaciones de Lambda sea compatible. Puede configurar
funciones para montar un sistema de archivos durante la inicialización con el protocolo NFS a través de la
red local dentro de una VPC. Lambda administra la conexión y cifra todo el tráfico hacia y desde el sistema
de archivos.
El sistema de archivos y la función Lambda deben estar en la misma región. Una función Lambda de
una cuenta puede montar un sistema de archivos en una cuenta diferente. En este caso, configure la
interconexión de VPC entre la función VPC y la VPC del sistema de archivos.
Note
Para configurar una función para que se conecte a un sistema de archivos, consulte Configuración
del acceso al sistema de archivos para las funciones Lambda (p. 91).
245
Conexiones
Amazon EFS es compatible con el bloqueo de archivos para evitar daños si varias funciones intentan
escribir en el mismo sistema de archivos al mismo tiempo. Amazon EFS sigue el protocolo NFS v4.1 para
el bloqueo consultivo y permite a sus aplicaciones utilizar bloqueos de todo el archivo o de intervalos del
tamaño de bytes.
Amazon EFS proporciona opciones para personalizar el sistema de archivos en función de la necesidad de
su aplicación de mantener un alto rendimiento a escala. Hay tres factores principales a tener en cuenta: el
número de conexiones, el rendimiento (en MiB por segundo) y las IOPS.
Cuotas
Para obtener detalles sobre las cuotas y los límites del sistema de archivos, consulte Cuotas para
sistemas de archivos de Amazon EFS en la Guía del usuario de Amazon Elastic File System.
Para evitar problemas con el escalado, el rendimiento y las IOPS, monitorice las métricas que Amazon
EFS envía a Amazon CloudWatch. Para obtener información general sobre la monitorización en Amazon
EFS, consulte Monitorización de Amazon EFS en Guía del usuario de Amazon Elastic File System.
Secciones
• Conexiones (p. 246)
• Rendimiento (p. 246)
• IOPS (p. 247)
Conexiones
Amazon EFS admite hasta 25,000 conexiones por sistema de archivos. Durante la inicialización, cada
instancia de una función crea una única conexión a su sistema de archivos que persiste en todas las
invocaciones. Esto significa que puede alcanzar la concurrencia 25,000 a través de una o más funciones
conectadas a un sistema de archivos. Para limitar el número de conexiones que crea una función, utilice la
concurrencia reservada (p. 62).
Sin embargo, cuando realiza cambios en el código o la configuración de su función a escala, hay un
aumento temporal en el número de instancias de función más allá de la concurrencia actual. Lambda
proporciona nuevas instancias para manejar nuevas solicitudes y hay algún retraso antes de que las
instancias antiguas cierren sus conexiones con el sistema de archivos. Para evitar alcanzar el límite
máximo de conexiones durante una implementación, utilice implementaciones continuas (p. 156). Con las
implementaciones continuas, cambia el tráfico gradualmente a la nueva versión cada vez que realiza un
cambio.
Si se conecta al mismo sistema de archivos desde otros servicios como Amazon EC2, también debe tener
en cuenta el comportamiento de escalado de las conexiones en Amazon EFS. Un sistema de archivos
admite la creación de hasta 3000 conexiones en una ráfaga, después de lo cual admite 500 nuevas
conexiones por minuto. Esto coincide con el comportamiento de escalado en ráfaga (p. 114) en Lambda,
que se aplica a todas las funciones de una región. Pero si están creando conexiones fuera de Lambda, es
posible que sus funciones no puedan escalar a toda velocidad.
Para monitorizar y activar una alarma en las conexiones, utilice la métrica ClientConnections.
Rendimiento
A escala, también es posible superar el rendimiento máximo de un sistema de archivos. En el modo de
ráfaga (predeterminado), un sistema de archivos tiene un bajo rendimiento de referencia que escala
linealmente con su tamaño. Para permitir ráfagas de actividad, el sistema de archivos recibe créditos de
ráfaga que le permiten utilizar 100 MiB/s o más de rendimiento. Los créditos se acumulan continuamente y
se gastan con cada operación de lectura y escritura. Si el sistema de archivos se queda sin créditos, limita
las operaciones de lectura y escritura más allá del rendimiento previsto, lo que puede provocar que las
invocaciones se agoten.
246
IOPS
Note
Si utiliza concurrencia provisionada (p. 62), su función puede consumir créditos de ráfaga incluso
cuando está inactiva. Con la concurrencia aprovisionada, Lambda inicializa las instancias de su
función antes de que se invoque y recicla las instancias cada pocas horas. Si utiliza archivos en
un sistema de archivos adjunto durante la inicialización, esta actividad puede utilizar todos los
créditos de ráfaga.
Para supervisar y activar una alarma en el rendimiento, utilice la métrica BurstCreditBalance. Debería
aumentar cuando la concurrencia de su función es baja y disminuir cuando es alta. Si siempre disminuye
o no se acumula lo suficiente durante la actividad baja para cubrir el tráfico máximo, es posible que tenga
que limitar la concurrencia de su función o habilitar el rendimiento provisionado.
IOPS
Las operaciones de entrada/salida por segundo (IOPS) son una medida del número de operaciones de
lectura y escritura procesadas por el sistema de archivos. En el modo propósito general, IOPS están
limitadas a favor de una latencia más baja, lo que es beneficioso para la mayoría de las aplicaciones.
Para supervisar y alarmar en IOPS en modo propósito general, utilice la métrica PercentIOLimit.
Si esta métrica alcanza el 100 %, su función puede agotar el tiempo de espera en espera de que se
completen las operaciones de lectura y escritura.
Uso de AWS Lambda con AWS IoT

AWS IoT proporciona una comunicación segura entre dispositivos conectados a Internet (como sensores)
y la nube de AWS. Esto le permite recopilar, almacenar y analizar los datos de telemetría de varios
dispositivos.
Puede crear reglas de AWS IoT para que sus dispositivos interactúen con los servicios de AWS. El motor
de reglas de AWS IoT proporciona un lenguaje basado en SQL para seleccionar datos de cargas de
mensajes y enviar los datos a otros servicios como Amazon S3, Amazon DynamoDB y AWS Lambda.
Cuando quiera invocar otro servicio de AWS o un servicio de terceros, defina una regla para invocar una
función Lambda.
Cuando un mensaje de IoT entrante desencadena la regla, AWS IoT invoca su función Lambda de forma
asíncrona (p. 101) y pasa los datos del mensaje de IoT a la función.
El siguiente ejemplo muestra una lectura de humedad del sensor de un invernadero. Los valores row y
pos identifican la ubicación del sensor. Este evento de ejemplo se basa en el tipo de invernadero de los
Tutoriales de reglas de AWS IoT.
Example Evento de mensaje de AWS IoT
{
"row" : "10",
"pos" : "23",
"moisture" : "75"
}
En la invocación asincrónica, Lambda pone en cola el mensaje y, si la función devuelve un error, lo intenta
de nuevo (p. 119). Configure la función con un destino (p. 104) para conservar los eventos que la función
no puede procesar.
Debe conceder permiso para que el servicio AWS IoT invoque su función de Lambda. Utilice el comando
add-permission para añadir una instrucción de permiso a la política basada en recursos de la función.
247
IoT Events

--statement-id iot-events --action "lambda:InvokeFunction" --principal
iotevents.amazonaws.com
{
"Statement": "{\"Sid\":\"iot-events\",\"Effect\":\"Allow\",\"Principal\":
{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":
\"arn:aws:lambda:us-west-2:123456789012:function:my-function\"}"
}
Para obtener más información acerca de cómo utilizar Lambda con AWS IoT, consulte Creación de una
regla de AWS Lambda.
Uso de AWS Lambda con AWS IoT Events

AWS IoT Events monitoriza las entradas desde varios sensores y aplicaciones de IoT para reconocer
patrones de evento. Luego realizar las acciones apropiadas cuando ocurren eventos. AWS IoT Events
recibe sus entradas como cargas JSON de muchas fuentes. AWS IoT Events admite eventos simples
(donde cada entrada desencadena un evento) y eventos complejos (donde se deben producir múltiples
entradas para desencadenar el evento).
Para usar AWS IoT Events, defina un modelo de detector, que es un modelo de máquina de estado de
su equipo o proceso. Además de los estados, se definen entradas y eventos para el modelo. También se
definen las acciones que se deben realizar cuando se produce un evento. Utilice una función Lambda para
una acción cuando desee invocar otro servicio de AWS (como Amazon Connect) o realizar acciones en
una aplicación externa (como la aplicación de planificación de recursos empresariales (ERP)).
Cuando se produce el evento, AWS IoT Events invoca su función de Lambda de forma asíncrona.
Proporciona información sobre el modelo del detector y el evento que desencadenó la acción. El siguiente
evento de mensaje de ejemplo se basa en las definiciones del ejemplo paso a paso sencillo de AWS IoT
Events.
Example evento de mensaje de AWS IoT Events
{
"event: ":{
"eventName": "myChargedEvent",
"eventTime": 1567797571647,
"payload":{
"detector":{
"detectorModelName": "AWS_IoTEvents_Hello_World1567793458261",
"detectorModelVersion": "4",
"keyValue": "100009"
},
"eventTriggerDetails":{
"triggerType": "Message",
"inputName": "AWS_IoTEvents_HelloWorld_VoltageInput",
"messageId": "64c75a34-068b-4a1d-ae58-c16215dc4efd"
},
"actionExecutionId": "49f0f32f-1209-38a7-8a76-d6ca49dd0bc4",
"state":{
"variables": {},
"stateName": "Charged",
"timers": {}
}
}
}
248
Kinesis Firehose
El evento que se pasa a la función de Lambda incluye los siguientes campos:
• eventName: el nombre de este evento en el modelo de detector.

• eventTime: la hora a la que se produjo el evento.
• detector: el nombre y la versión del modelo de detector.
• eventTriggerDetails: una descripción de la entrada que desencadenó el evento.
• actionExecutionId: el identificador de ejecución único de la acción.
• state: el estado del modelo de detector cuando se produjo el evento.
• stateName: el nombre del estado en el modelo de detector.
• timers: cualquier temporizador que se establezca en este estado.
• variables: cualquier valor de variable que se establece en este estado.
Debe conceder permiso para que el servicio AWS IoT Events invoque su función de Lambda. Utilice el
comando add-permission para añadir una instrucción de permiso a la política basada en recursos de la
función.

--statement-id iot-events --action "lambda:InvokeFunction" --principal
iotevents.amazonaws.com
{
"Statement": "{\"Sid\":\"iot-events\",\"Effect\":\"Allow\",\"Principal\":{\"Service
\":\"iotevents.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":
\"arn:aws:lambda:us-west-2:123456789012:function:my-function\"}"
}
Para obtener más información sobre cómo utilizar Lambda con AWS IoT Events, consulte Uso de AWS IoT
Events con otros servicios.
Uso de AWS Lambda con Amazon Kinesis Data

Firehose
Amazon Kinesis Data Firehose captura, transforma y carga datos de streaming en servicios posteriores
como Kinesis Data Analytics o Amazon S3. Es posible escribir funciones de Lambda para realizar un
procesamiento adicional personalizado de los datos antes de enviarlos a los servicios posteriores.
Example Evento de mensaje de Amazon Kinesis Data Firehose
{
"invocationId": "invoked123",
"deliveryStreamArn": "aws:lambda:events",
"region": "us-west-2",
"records": [
{
"data": "SGVsbG8gV29ybGQ=",
"recordId": "record1",
"approximateArrivalTimestamp": 1510772160000,
"kinesisRecordMetadata": {
"partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c317a",
249
Flujos de Kinesis
"approximateArrivalTimestamp": "2012-04-23T18:25:43.511Z",
"sequenceNumber": "49546986683135544286507457936321625675700192471156785154",
"subsequenceNumber": ""
}
},
{
"data": "SGVsbG8gV29ybGQ=",
"recordId": "record2",
"approximateArrivalTimestamp": 151077216000,
"kinesisRecordMetadata": {
"partitionKey": "4d1ad2b9-24f8-4b9d-a088-76e9947c318a",
"approximateArrivalTimestamp": "2012-04-23T19:25:43.511Z",
"sequenceNumber": "49546986683135544286507457936321625675700192471156785155",
"subsequenceNumber": ""
}
}
]
}
Para obtener más información, consulte Transformación de datos de Amazon Kinesis Data Firehose en la
Guía para desarrolladores de Kinesis Data Firehose.
Uso de AWS Lambda con Amazon Kinesis

Puede utilizar una función de AWS Lambda para procesar los registros de un flujo de datos de Amazon
Kinesis.
Un flujo de datos de Kinesis es un conjunto de particiones. Cada partición contiene una secuencia de
registros de datos. Un consumidor es una aplicación que procesa los datos procedentes de un flujo de
datos de Kinesis. Puede asignar una función Lambda a un consumidor de rendimiento compartido (iterador
estándar) o a un consumidor de rendimiento dedicado con distribución ramificada mejorada.
Para iteradores estándar, Lambda sondea cada partición de la secuencia de Kinesis en busca de registros
utilizando el protocolo HTTP. El mapeo de origen de eventos comparte el rendimiento de lectura con otros
consumidores de la partición.
Para minimizar la latencia y maximizar el rendimiento de lectura, puede crear un consumidor de flujo de
datos con distribución ramificada mejorada. Los consumidores de flujos obtienen una conexión dedicada a
cada partición que no afecta a las demás aplicaciones que leen el flujo. El rendimiento dedicado puede ser
útil si hay muchas aplicaciones que leen los mismos datos, o si se está reprocesando un flujo con registros
de gran tamaño. Kinesis inserta los registros en Lambda a través de HTTP/2.
Para obtener información detallada sobre los flujos de datos de Kinesis, consulte Lectura de datos de
Amazon Kinesis Data Streams.
Note
El manejo de errores no está disponible para los consumidores de secuencias HTTP/2.
Lambda lee registros del flujo de datos e invoca la función sincrónicamente (p. 100) con un evento que
contenga registros de flujo. Lambda lee registros en lotes e invoca la función para procesar registros desde
el lote.
Example Evento de registro de Kinesis.
{
"Records": [
{
"kinesis": {
250
Flujos de Kinesis
"kinesisSchemaVersion": "1.0",
"partitionKey": "1",
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data": "SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
"approximateArrivalTimestamp": 1545084650.987
},
"eventSource": "aws:kinesis",
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"eventName": "aws:kinesis:record",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream"
},
{
"kinesis": {
"sequenceNumber":
"49590338271490256608559692540925702759324208523137515618",
"data": "VGhpcyBpcyBvbmx5IGEgdGVzdC4=",
},
"eventID":
"shardId-000000000006:49590338271490256608559692540925702759324208523137515618",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-role",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream"
}
]
}
De forma predeterminada, Lambda llama a su función en cuanto los registros están disponibles en el flujo.
Si el lote que lee desde el flujo solo tiene un registro, Lambda solo envía un registro a la función. Para
evitar invocar a la función con un número de registros pequeño, puede indicar al origen del evento que
almacene en búfer registros durante hasta 5 minutos configurando una ventana de lote. Antes de invocar
a la función, Lambda sigue leyendo registros desde el flujo hasta que haya recopilado un lote completo o
hasta que caduca la ventana de lote.
Si la función devuelve un error, Lambda volverá a intentar ejecutar el lote hasta que el procesamiento
se realice correctamente o los datos caduquen. Para evitar particiones detenidas, puede configurar la
asignación del origen de eventos para que vuelva a intentarlo con un tamaño de lote menor, para que limite
el número de reintentos o para que se descarten los registros que sean muy antiguos. Si desea conservar
los eventos descartados, puede configurar la asignación del origen de eventos para que envíe información
sobre los lotes con errores a una cola de SQS o un tema de SNS.
También puede aumentar la simultaneidad procesando varios lotes de cada partición en paralelo. Lambda
puede procesar hasta 10 lotes en cada partición simultáneamente. Si aumenta el número de lotes
simultáneos en cada partición, Lambda seguirá garantizando que el procesamiento se realiza en orden en
el nivel de la clave de partición.
Secciones
• Configurar su flujo de datos y función. (p. 252)
• Configuración de una secuencia como un origen de eventos (p. 253)
• API de mapeo de origen de eventos (p. 254)
251
Configurar su flujo de datos y función.
• Control de errores (p. 256)

• Métricas de Amazon CloudWatch (p. 257)
• Tutorial: uso de AWS Lambda con Amazon Kinesis (p. 257)
• Código de función de muestra (p. 261)
• Plantilla de AWS SAM para una aplicación de Kinesis (p. 264)
Configurar su flujo de datos y función.

Su función de Lambda es una aplicación consumidora para su flujo de datos. Procesa un lote de registros
a la vez desde cada partición. Puede mapear una función de Lambda a un flujo de datos (iterador
estándar) o a un consumidor de un flujo (distribución ramificada mejorada).
Para los iteradores estándar, Lambda sondea cada partición del flujo de Kinesis y busca registros una vez
por segundo. Cuando hay más registros disponibles, Lambda sigue procesando lotes hasta que la función
se pone al día con el flujo. El mapeo de origen de eventos comparte el rendimiento de lectura con otros
consumidores de la partición.
Para minimizar la latencia y maximizar el rendimiento de lectura, cree un consumidor de flujo de datos
con distribución ramificada mejorada. Los consumidores con distribución ramificada mejorada obtienen
una conexión dedicada a cada partición que no afecta a las demás aplicaciones que leen el flujo. Los
consumidores de flujos utilizan HTTP/2 para reducir la latencia enviando los registros a Lambda a través
de una conexión de larga duración y mediante la compresión de los encabezados de las solicitudes. Es
posible crear un consumidor de flujos con la API RegisterStreamConsumer de Kinesis.
$ aws kinesis register-stream-consumer --consumer-name con1 \

--stream-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream
{
"Consumer": {
"ConsumerName": "con1",
"ConsumerARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream/
consumer/con1:1540591608",
"ConsumerStatus": "CREATING",
"ConsumerCreationTimestamp": 1540591608.0
}
}
Para incrementar la velocidad con la que la función procesa los registros, añada particiones al flujo de
datos. Lambda procesa los registros de cada partición por orden. Deja de procesar registros adicionales
en una partición si la función devuelve un error. Al haber más particiones, se procesan más lotes
simultáneamente, lo que reduce el impacto de los errores de simultaneidad.
Si la función no puede aumentar para administrar el número total de lotes simultáneos, solicite un aumento
de cuota (p. 31) o reserve la simultaneidad (p. 62) para la función.

Lambda necesita los siguientes permisos para administrar los recursos relacionados con el flujo de datos
de Kinesis. Añádalos a rol de ejecución (p. 33) de su función.
• kinesis:DescribeStream
• kinesis:DescribeStreamSummary
• kinesis:GetRecords
• kinesis:GetShardIterator
• kinesis:ListShards
• kinesis:ListStreams
252
Configuración de una secuencia como un origen de eventos
• kinesis:SubscribeToShard
La política administrada AWSLambdaKinesisExecutionRole contiene los permisos siguientes: Para

obtener más información, consulte Rol de ejecución de AWS Lambda (p. 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:

Configuración de una secuencia como un origen de

eventos
Cree un mapeo de origen de eventos para indicar a Lambda que envíe registros de un flujo de datos a
una función de Lambda. Puede crear varios mapeos de orígenes de eventos para procesar los mismos
datos con distintas funciones de Lambda o para procesar elementos de varios flujos de datos con una sola
función.
Para configurar la función para leer de Kinesis en la consola de Lambda, cree un desencadenador de
Kinesis.

Lambda admite las siguientes opciones para los orígenes de eventos de Kinesis.
• Kinesis stream (Flujo de Kinesis): el flujo de – Kinesis cuyos registros se leen.

• Consumer (Consumidor)– (opcional): utilizar un consumidor de flujos para leer los datos del flujo a través
de una conexión dedicada.
• Batch size (Tamaño del lote): número de registros que hay que enviar a la función en cada lote, hasta 10
000. Lambda pasa todos los registros del lote a la función en una sola llamada, siempre que el tamaño
total de los eventos no supere el límite de carga (p. 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, todos los registros existentes o los
registros creados después de cierta fecha.
• Latest (Más recientes): procesar los registros nuevos que se añaden al flujo principal.
• Trim horizon (Horizonte de supresión): procesar todos los registros del flujo.
• At timestamp (En marca temporal): procesar los registros comenzando a partir de un momento
determinado.
Tras procesar cualquier registro existente, la función es alcanzada y continúa procesando registros
nuevos.
253
• 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.
Note
Kinesis cobra por cada partición y, para una distribución ramificada mejorada, por los datos leídos
desde la frecuencia. Para obtener más información sobre precios, consulte precios de Amazon
Kinesis.


Para crear el mapeo de orígenes de eventos con la AWS CLI, use el comando create-event-source-
mapping. En el siguiente ejemplo, se utiliza la AWS CLI para asignar una función denominada my-
function a un flujo de datos de Kinesis. El flujo de datos se especifica mediante un nombre de recurso
de Amazon (ARN) con un tamaño de lote de 500, comenzando desde una marca temporal en tiempo Unix.
$ aws lambda create-event-source-mapping --function-name my-function \

--batch-size 500 --starting-position AT_TIMESTAMP --starting-position-timestamp 1541139109
\
--event-source-arn arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream
{
"UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284",
"BatchSize": 500,
"EventSourceArn": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-stream",
"LastModified": 1541139209.351,
254
}
Para utilizar un consumidor, especifique el ARN del consumidor en lugar del ARN del flujo.
Configure otras opciones para personalizar el modo en que se procesan los lotes y especificar cuándo
deben descargarse los registros que no se pueden procesar. En el siguiente ejemplo, se actualiza la
asignación de un origen de eventos para enviar un registro de error a una cola de SQS después de dos
reintentos o si los registros tienen más de una hora de antigüedad.
$ aws lambda update-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b \

--maximum-retry-attempts 2 --maximum-record-age-in-seconds 3600
--destination-config '{"OnFailure": {"Destination": "arn:aws:sqs:us-
east-2:123456789012:dlq"}}'
{
"BatchSize": 100,
"State": "Updating",
}
La configuración actualizada se aplica de forma asincrónica y no se refleja en la salida hasta que se

completa el proceso. Utilice el comando get-event-source-mapping para ver el estado actual.
$ aws lambda get-event-source-mapping --uuid f89f8514-cdd9-4602-9e1f-01a5b77d449b

{
"BatchSize": 100,
"State": "Enabled",
"OnFailure": {
"Destination": "arn:aws:sqs:us-east-2:123456789012:dlq"
}
},
}
Para procesar varios lotes simultáneamente, utilice la opción --parallelization-factor.
$ aws lambda update-event-source-mapping --uuid 2b733gdc-8ac3-cdf5-af3a-1827b3b11284 \
255
Control de errores
--parallelization-factor 5
Control de errores
La asignación del origen de eventos que lee los registros de la secuencia de Kinesis invoca la función de
forma sincrónica y reintenta la operación si se producen errores. Si la función se ve limitada o el servicio de
Lambda devuelve un error sin invocar la función, Lambda vuelve a intentarlo hasta que el registro expira o
supera la antigüedad máxima establecida en la asignación del origen de eventos.
Si la función recibe los registros pero devuelve un error, Lambda lo vuelve a intentar hasta que vencen los
registros del lote, se supera la antigüedad máxima o se alcanza la cuota de reintentos especificada. En el
caso de los errores de funciones, también puede configurar la asignación del origen de eventos para que
divida en dos los lotes que presentan errores. Al intentarlo con lotes más pequeños, se aíslan los registros
erróneos y se solucionan problemas relacionadas con el tiempo de espera. Los lotes divididos no se tienen
en cuenta para calcular la cuota de reintentos.
Si las medidas de administración de errores no funcionan, Lambda descarta los registros y sigue
procesando los lotes de la secuencia. Con la configuración predeterminada, esto significa que un registro
erróneo puede bloquear el procesamiento de la partición afectada durante un máximo de one week.
Para evitar esto, configure la asignación del origen de eventos de la función con un número razonable de
reintentos y una antigüedad de registro máxima que se ajuste a su caso de uso.
Para mantener un registro de los lotes descartados, configure un destino de evento fallido. Lambda enviará
un documento a la cola o al tema de destino con información sobre el lote.
Para configurar un destino para registros de eventos con errores

4. En Source (Origen), elija Stream invocation (Invocación por secuencias).
5. En Stream (Secuencia), elija una secuencia que esté asignada a la función.
El siguiente ejemplo muestra un registro de invocación para un flujo de Kinesis.
{
"requestContext": {
"requestId": "c9b8fa9f-5a7f-xmpl-af9c-0c604cde93a5",
},
"statusCode": 200,
},
"version": "1.0",
"timestamp": "2019-11-14T00:38:06.021Z",
"KinesisBatchInfo": {
256
"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"
}
}
Puede utilizar esta información para recuperar los registros afectados de la secuencia y solucionar los
problemas. Los registros reales no están incluidos, por lo que debe procesar este registro y recuperarlos
de la secuencia antes de que venzan y se pierdan.

Lambda emite la métrica IteratorAge cuando la función termina de procesar un lote de registros.
La métrica indica la antigüedad del último registro del lote cuando acabo el proceso. Si la función está
procesando nuevos eventos, puede utilizar la antigüedad del iterador para estimar la latencia entre el
momento en que se añade un registro y el momento en que la función lo procesa.
Una tendencia ascendente en la antigüedad del iterador puede indicar problemas con la función. Para
obtener más información, consulte Trabajar con métricas de funciones de AWS Lambda (p. 464).
Tutorial: uso de AWS Lambda con Amazon Kinesis

En este tutorial, se crea una función de Lambda para consumir eventos de un flujo de Kinesis. En el
diagrama siguiente se ilustra el flujo de la aplicación:
1. Una aplicación personalizada escribe los registros en el flujo.

2. AWS Lambda sondea el flujo y, cuando detecta registros nuevos en él, llama a la función de Lambda.
3. AWS Lambda ejecuta la función de Lambda asumiendo el rol de ejecución que se especificó en el
momento de crear la función de Lambda.
Requisitos previos
257
Tutorial

this is output

AWS.


• Permissions (Permisos): AWSLambdaSQSQueueExecutionRole.
• Role name (Nombre de rol): lambda-kinesis-role.
La política AWSLambdaKinesisExecutionRole tiene permisos que la función necesita para leer elementos
de Kinesis y escribir registros a CloudWatch Logs.
A continuación se muestra código de ejemplo que recibe un evento de Kinesis como entrada y procesa
Note
Para ver código de muestra en otros lenguajes, consulte Código de función de muestra (p. 261).
Example index.js

//console.log(JSON.stringify(event, null, 2));
// Kinesis data is base64 encoded so decode here
var payload = Buffer.from(record.kinesis.data, 'base64').toString('ascii');
console.log('Decoded payload:', payload);
});
};

258
Tutorial
$ aws lambda create-function --function-name ProcessKinesisRecords \

--role arn:aws:iam::123456789012:role/lambda-kinesis-role

Invoque la función de Lambda manualmente mediante el comando invoke de la CLI de AWS Lambda y
un evento de Kinesis de muestra.
{
"Records": [
{
"kinesis": {
"sequenceNumber":
"49590338271490256608559692538361571095921575989136588898",
"data": "SGVsbG8sIHRoaXMgaXMgYSB0ZXN0Lg==",
},
"eventID":
"shardId-000000000006:49590338271490256608559692538361571095921575989136588898",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/lambda-kinesis-role",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/lambda-
stream"
}
]
}
2. Utilice el comando invoke para enviar el evento a la función.
$ aws lambda invoke --function-name ProcessKinesisRecords --payload file://input.txt

out.txt
La respuesta se guardará en el archivo out.txt.
Crear un flujo de Kinesis

Utilice el comando create-stream para crear un flujo.
$ aws kinesis create-stream --stream-name lambda-stream --shard-count 1
Ejecute el siguiente comando describe-stream para obtener el ARN del flujo.
$ aws kinesis describe-stream --stream-name lambda-stream

{
"StreamDescription": {
259
Tutorial
"Shards": [
{
"ShardId": "shardId-000000000000",
"HashKeyRange": {
"StartingHashKey": "0",
"EndingHashKey": "340282366920746074317682119384634633455"
},
"SequenceNumberRange": {
"StartingSequenceNumber":
"49591073947768692513481539594623130411957558361251844610"
}
}
],
"StreamARN": "arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream",
"StreamName": "lambda-stream",
"StreamStatus": "ACTIVE",
"RetentionPeriodHours": 24,
"EnhancedMonitoring": [
{
"ShardLevelMetrics": []
}
],
"EncryptionType": "NONE",
"KeyId": null,
"StreamCreationTimestamp": 1544828156.0
}
}
Utilice el ARN del flujo en el siguiente paso para asociar el flujo a la función de Lambda.
Añadir un origen de eventos en AWS Lambda

Ejecute el comando siguiente AWS CLI add-event-source.
$ aws lambda create-event-source-mapping --function-name ProcessKinesisRecords \

--event-source arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream \
--batch-size 100 --starting-position LATEST
Tenga en cuenta el ID de mapeo para un uso posterior. Para obtener una lista de mapeos de orígenes de
eventos, ejecute el comando list-event-source-mappings.
$ aws lambda list-event-source-mappings --function-name ProcessKinesisRecords \

--event-source arn:aws:kinesis:us-west-2:123456789012:stream/lambda-stream
En la respuesta, puede comprobar que el valor de estado es enabled. Los mapeos de orígenes de
eventos se pueden deshabilitar para poner en pausa temporalmente el sondeo sin perder de registros.
Para probar el mapeo de origen de eventos, añada los registros de eventos a su flujo de Kinesis. El valor
de --data es una cadena que la CLI codifica en base64 antes de enviarlo a Kinesis. Puede ejecutar el
mismo comando más de una vez para añadir varios registros al flujo.
$ aws kinesis put-record --stream-name lambda-stream --partition-key 1 \

--data "Hello, this is a test."
Lambda utiliza el rol de ejecución para leer los registros desde el flujo. A continuación, se invoca la función
de Lambda y se pasan lotes de registros. La función descodifica los datos de cada registro y los registra,
enviando la salida a CloudWatch Logs. Puede ver los registros en la consola deCloudWatch.
260
Código de muestra
Código de función de muestra

Para procesar eventos desde Amazon Kinesis, itere a través de los registros incluidos en el objeto de
evento y decodifique los datos codificados en Base64 incluidos en cada uno.
Note
El código de esta página no admite registros agregados. Puede deshabilitar la agregación en

la configuración de Kinesis Producer Library o utilice la biblioteca de agregación de registros de
Kinesis para desagregar registros.
Temas
• Node.js 8 (p. 261)
• Java 11 (p. 261)
• C# (p. 262)
• Python 3 (p. 263)
• Go (p. 263)
Node.js 8
A continuación se muestra código de ejemplo que recibe un evento de Kinesis como entrada y procesa
Example index.js

//console.log(JSON.stringify(event, null, 2));
// Kinesis data is base64 encoded so decode here
var payload = Buffer.from(record.kinesis.data, 'base64').toString('ascii');
console.log('Decoded payload:', payload);
});
};
Java 11
A continuación, se muestra código de ejemplo de Java que recibe datos de registros de eventos de Kinesis
como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
En el código, recordHandler es el controlador. Este controlador utiliza la clase KinesisEvent

predefinida, que se define en la biblioteca aws-lambda-java-events.
Example ProcessKinesisEvents.java
package example;
261
Código de muestra
import com.amazonaws.services.lambda.runtime.events.KinesisEvent;
import com.amazonaws.services.lambda.runtime.events.KinesisEvent.KinesisEventRecord;
public class ProcessKinesisRecords implements RequestHandler<KinesisEvent, Void>{

@Override
public Void handleRequest(KinesisEvent event, Context context)
{
for(KinesisEventRecord rec : event.getRecords()) {
System.out.println(new String(rec.getKinesis().getData().array()));
}
return null;
}
}
Si el controlador vuelve normalmente sin excepciones, Lambda considera que el lote de registros de
entrada se ha procesado correctamente y empieza a leer nuevos registros en el flujo. Si el controlador
genera una excepción, Lambda considera que el lote de registros de entrada no se ha procesado e invoca
de nuevo la función con el mismo lote de registros.
Dependencias.
• aws-java-sdk
Java (p. 386).
C#
A continuación, se muestra código de ejemplo de C# que recibe datos de registros de eventos de Kinesis
En el código, HandleKinesisRecord es el controlador. Este controlador utiliza la clase KinesisEvent

predefinida, que se define en la biblioteca Amazon.Lambda.KinesisEvents.
Example ProcessingKinesisEvents.cs
using System;
using System.IO;
using System.Text;
using Amazon.Lambda.KinesisEvents;
namespace KinesisStreams
{
public class KinesisSample
{
[LambdaSerializer(typeof(JsonSerializer))]
public void HandleKinesisRecord(KinesisEvent kinesisEvent)
{
Console.WriteLine($"Beginning to process {kinesisEvent.Records.Count}
records...");
foreach (var record in kinesisEvent.Records)

{
262
Código de muestra
Console.WriteLine($"Event ID: {record.EventId}");

Console.WriteLine($"Event Name: {record.EventName}");
string recordData = GetRecordContents(record.Kinesis);

Console.WriteLine($"Record Data:");
Console.WriteLine(recordData);
}
Console.WriteLine("Stream processing complete.");
}
private string GetRecordContents(KinesisEvent.Record streamRecord)

{
using (var reader = new StreamReader(streamRecord.Data, Encoding.ASCII))
{
return reader.ReadToEnd();
}
}
}
}
Python 3
A continuación se muestra código de ejemplo de Python que recibe datos de registros de eventos de
Kinesis como entrada y los procesa. Con fines ilustrativos, el código escribe parte de los datos de los
Example ProcessKinesisRecords.py

#import json
import base64
#Kinesis data is base64 encoded so decode here
payload=base64.b64decode(record["kinesis"]["data"])
print("Decoded payload: " + str(payload))
Go
A continuación se muestra código de ejemplo de Go que recibe datos de registros de eventos de Kinesis
Example ProcessKinesisRecords.go
import (
"strings"
)
func handler(ctx context.Context, kinesisEvent events.KinesisEvent) {

for _, record := range kinesisEvent.Records {
kinesisRecord := record.Kinesis
dataBytes := kinesisRecord.Data
263
dataText := string(dataBytes)
fmt.Printf("%s Data = %s \n", record.EventName, dataText)

}
}
Plantilla de AWS SAM para una aplicación de Kinesis

tutorial (p. 257). La función y controlador de la plantilla corresponden al código de Node.js. Si utiliza un
código de muestra diferente, actualice los valores en consecuencia.
Example template.yaml: flujo de Kinesis
Resources:
LambdaFunction:
Properties:
Runtime: nodejs12.x
Timeout: 10
Tracing: Active
Events:
Stream:
Type: Kinesis
Properties:
Stream: !GetAtt stream.Arn
BatchSize: 100
StartingPosition: LATEST
stream:
Type: AWS::Kinesis::Stream
Properties:
ShardCount: 1
Outputs:
FunctionName:
Description: "Function name"
Value: !Ref LambdaFunction
StreamARN:
Description: "Stream ARN"
Value: !GetAtt stream.Arn
La plantilla crea una función de Lambda, un flujo de Kinesis y un mapeo de origen de eventos. El mapeo
de origen de eventos lee del flujo e invoca la función.
Para utilizar un consumidor de flujos HTTP/2 (p. 252), cree el consumidor en la plantilla y configure el
mapeo de origen de eventos para que lea del consumidor en lugar de leer del flujo.
Example template.yaml: consumidor de flujos de Kinesis
264
Lex
Description: A function that processes data from a Kinesis stream.

Resources:
function:
Properties:
Runtime: nodejs12.x
Timeout: 10
Tracing: Active
Events:
Stream:
Type: Kinesis
Properties:
Stream: !GetAtt streamConsumer.ConsumerARN
StartingPosition: LATEST
BatchSize: 100
stream:
Type: "AWS::Kinesis::Stream"
Properties:
ShardCount: 1
streamConsumer:
Type: "AWS::Kinesis::StreamConsumer"
Properties:
StreamARN: !GetAtt stream.Arn
ConsumerName: "TestConsumer"
Outputs:
FunctionName:
Description: "Function name"
Value: !Ref function
StreamARN:
Description: "Stream ARN"
Value: !GetAtt stream.Arn
ConsumerARN:
Description: "Stream consumer ARN"
Value: !GetAtt streamConsumer.ConsumerARN
Uso de AWS Lambda con Amazon Lex

Puede utilizar Amazon Lex para integrar un bot de conversación en su aplicación. El bot de Amazon Lex
proporciona una interfaz de conversación con sus usuarios. Amazon Lex proporciona una integración
prediseñada con Lambda que permite usar una función de Lambda con el bot de Amazon Lex.
Al configurar un bot de Amazon Lex, puede especificar una función de Lambda para llevar a cabo la
validación, el procesamiento o ambos. Para la validación, Amazon Lex invoca la función de Lambda
después de cada respuesta del usuario. La función de Lambda puede validar la respuesta y proporcionar
retroalimentación correctiva al usuario, si es necesario. Para el procesamiento, Amazon Lex invoca la
función de Lambda para procesar la solicitud del usuario una vez que el bot haya recopilado correctamente
toda la información requerida y haya recibido la confirmación del usuario.
Puede administrar la simultaneidad de la función de Lambda (p. 62) para controlar el número máximo de
conversaciones de bot simultáneas que se pueden atender. La API de Amazon Lex devuelve un código de
estado HTTP 429 (Too Many Requests (Demasiadas solicitudes)) si se alcanza la simultaneidad máxima
de la función.
La API devuelve un código de estado HTTP 424 (Dependency Failed Exception (Excepción con error de
dependencia)) si la función Lambda genera una excepción.
265
Lex
El bot de Amazon Lex invoca la función de Lambda de forma síncrona (p. 100). El parámetro de evento
contiene información sobre el bot y el valor de cada ranura del diálogo. El parámetro invocationSource
indica si la función de Lambda debe validar las entradas (DialogCodeHook) o procesar la intención
(FulfillmentCodeHook).
Example Evento de mensaje de Amazon Lex
{
"messageVersion": "1.0",
"invocationSource": "FulfillmentCodeHook",
"userId": "ABCD1234",
"sessionAttributes": {
"key1": "value1",
"key2": "value2",
},
"bot": {
"name": "OrderFlowers",
"alias": "prod",
"version": "1"
},
"outputDialogMode": "Text",
"currentIntent": {
"name": "OrderFlowers",
"slots": {
"FlowerType": "lilies",
"PickupDate": "2030-11-08",
"PickupTime": "10:00"
},
"confirmationStatus": "Confirmed"
}
}
Amazon Lex espera una respuesta de una función de Lambda con el siguiente formato: El campo
dialogAction es obligatorio. Los campos sessionAttributes y recentIntentSummaryView son
opcionales.
Example Evento de mensaje de Amazon Lex
{
"sessionAttributes": {
"key1": "value1",
"key2": "value2"
...
},
"recentIntentSummaryView": [
{
"intentName": "Name",
"checkpointLabel": "Label",
"slots": {
"slot name": "value",
"slot name": "value"
},
"confirmationStatus": "None, Confirmed, or Denied (intent confirmation, if
configured)",
"dialogActionType": "ElicitIntent, ElicitSlot, ConfirmIntent, Delegate, or Close",
"fulfillmentState": "Fulfilled or Failed",
"slotToElicit": "Next slot to elicit
}
],
"dialogAction": {
"type": "Close",
"fulfillmentState": "Fulfilled",
"message": {
266
Roles y permisos
"contentType": "PlainText",
"content": "Thanks, your pizza has been ordered."
},
"responseCard": {
"version": integer-value,
"contentType": "application/vnd.amazonaws.card.generic",
"genericAttachments": [
{
"title":"card-title",
"subTitle":"card-sub-title",
"imageUrl":"URL of the image to be shown",
"attachmentLinkUrl":"URL of the attachment to be associated with the card",
"buttons":[
{
"text":"button-text",
"value":"Value sent to server on button click"
}
]
}
]
}
}
}
Tenga en cuenta que los campos adicionales necesarios para dialogAction varían según el valor
del campo type. Para obtener más información acerca de los campos de evento y respuesta, consulte
Formato del evento de entrada y de la respuesta de la Lambda en la Guía para desarrolladores de Amazon
Lex. Para ver un tutorial de ejemplo que muestra cómo utilizar Lambda con Amazon Lex, consulte Ejercicio
1: creación de un bot de Amazon Lex mediante un proyecto en la Guía para desarrolladores de Amazon
Lex.
Roles y permisos
Debe configurar un rol vinculado a servicio como rol de ejecución (p. 33) de la función. Amazon Lex define
el rol vinculado a servicio con permisos predefinidos. Al crear un bot de Amazon Lex mediante la consola,
el rol vinculado a servicio se crea automáticamente. Para crear un rol vinculado a servicio con la CLI de
AWS, utilice el comando create-service-linked-role.
$ aws iam create-service-linked-role --aws-service-name lex.amazonaws.com
Este comando crea el siguiente rol.
{
"Role": {
"Version": "2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Effect": "Allow",
"Principal": {
"Service": "lex.amazonaws.com"
}
}
]
},
"RoleName": "AWSServiceRoleForLexBots",
"Path": "/aws-service-role/lex.amazonaws.com/",
"Arn": "arn:aws:iam::account-id:role/aws-service-role/lex.amazonaws.com/
AWSServiceRoleForLexBots"
}
267
RDS
Si la función de Lambda utiliza otros servicios de AWS, debe agregar los permisos correspondientes al rol
vinculado a servicio.
Utilice una política de permisos basada en recursos para permitir que la intención de Amazon Lex
invoque la función de Lambda. Si utiliza la consola de Amazon Lex, la política de permisos se crea
automáticamente. En la CLI de AWS, utilice el comando Lambda add-permission para establecer el
permiso. En el ejemplo siguiente, se establece el permiso para la intención OrderFlowers.
aws lambda add-permission \

--function-name OrderFlowersCodeHook \
--statement-id LexGettingStarted-OrderFlowersBot \
--action lambda:InvokeFunction \
--principal lex.amazonaws.com \
--source-arn "arn:aws:lex:us-east-1:123456789012 ID:intent:OrderFlowers:*"
Uso de AWS Lambda con Amazon RDS

Puede utilizar AWS Lambda para procesar las notificaciones de eventos desde una base de datos de
Amazon Relational Database Service (Amazon RDS). Amazon RDS envía notificaciones a un tema de
Amazon Simple Notification Service (Amazon SNS), que puede configurar para invocar una función de
Lambda. Amazon SNS envuelve el mensaje desde Amazon RDS en su propio documento de evento y lo
envía a la función.
Example Mensaje de Amazon RDS en un evento de Amazon SNS
{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:rds-lambda:21be56ed-
a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificationService-
ac565b8b1a6c5d002d285f9598aa1d9b.pem",
"Message": "{\"Event Source\":\"db-instance\",\"Event Time\":\"2019-01-02
12:45:06.000\",\"Identifier Link\":\"https://console.aws.amazon.com/rds/home?region=eu-
west-1#dbinstance:id=dbinstanceid\",\"Source ID\":\"dbinstanceid\",\"Event ID\":\"http://
docs.amazonwebservices.com/AmazonRDS/latest/UserGuide/USER_Events.html#RDS-EVENT-0002\",
\"Event Message\":\"Finished DB Instance backup\"}",
"MessageAttributes": {},
"Type": "Notification",
"UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?
Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-
lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "RDS Notification Message"
}
}
]
268
Tutorial: Amazon RDS
Para obtener instrucciones sobre cómo configurar una base de datos de Amazon RDS para enviar
notificaciones, consulte Uso de las notificaciones de eventos de Amazon RDS en la Guía del usuario de
Amazon Relational Database Service.
Para obtener más información sobre cómo utilizar Amazon SNS como disparador, consulte Uso de AWS
Lambda con Amazon SNS (p. 290).
Temas
• 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 RDS en una Amazon
VPC
• Lanzar una instancia del motor de base de datos MySQL de Amazon RDS en la Amazon VPC
predeterminada. En la instancia de MySQL, debe crear una base de datos (ExampleDB) con una tabla
de muestra (Employee). Para obtener más información acerca de Amazon RDS, consulte Amazon RDS.
• Crear una función de Lambda para obtener acceso a la base de datos ExampleDB, crear una tabla
(Employee), añadir algunos registros y recuperar los registros de la tabla.
• Invocar la función de Lambda y verificar los resultados de la consulta. De este modo, se comprueba que
la función de Lambda ha podido tener acceso a la instancia de MySQL de RDS en la VPC.
Para obtener más información sobre el uso de Lambda con Amazon VPC, consulte Configuración de una
función de Lambda para obtener acceso a los recursos de una VPC (p. 81).
Requisitos previos

this is output

AWS.
269


• Permissions (Permisos) – AWSLambdaVPCAccessExecutionRole.
• Role name (Nombre de rol): lambda-vpc-role.
El AWSLambdaVPCAccessExecutionRole tiene permisos que la función necesita para administrar las

conexiones de red a una VPC.
Crear una instancia de base de datos de Amazon RDS

En este tutorial, la función de Lambda del ejemplo crea una tabla (Employee), introduce algunos registros
y, a continuación, recupera los registros. La tabla creada por la función de Lambda tiene el siguiente
esquema:
Employee(EmpID, Name)
Donde EmpID es la clave principal. Ahora, debe añadir algunos registros a esta tabla.
En primer lugar, lance una instancia de MySQL de RDS en la VPC predeterminada con la base de datos
ExampleDB. Si ya tiene una instancia de MySQL de RDS ejecutándose en la VPC predeterminada, omita
este paso.
Puede lanzar una instancia de MySQL de RDS utilizando uno de los siguientes métodos:
• Siga las instrucciones de Crear una instancia de base de datos MySQL y conectarse a una base de
datos en una instancia de base de datos MySQL en la Guía del usuario de Amazon RDS.
• Use el siguiente comando: AWS CLI
$ aws rds create-db-instance --db-name ExampleDB --engine MySQL \

--db-instance-identifier MySQLForLambdaTest --backup-retention-period 3 \
--db-instance-class db.t2.micro --allocated-storage 5 --no-publicly-accessible \
--master-username username --master-user-password password
Anote el nombre de la base de datos, el nombre de usuario y la contraseña. Necesitará la dirección del
cliente (punto de enlace) de la base de datos que puede obtener en la consola de RDS. Puede que tenga
que esperar hasta que el estado de la instancia esté disponible y el valor del punto de enlace aparezca en
la consola.
Crear un paquete de implementación.

En el siguiente ejemplo de código de Python se ejecuta una consulta SELECT en la tabla Employee de
la instancia de RDS de MySQL que ha creado en la VPC. El código crea una tabla en la base de datos
ExampleDB, añade registros de muestra y recupera los registros.
Example app.py
import sys
import logging
270
import rds_config
import pymysql
#rds settings
rds_host = "rds-instance-endpoint"
name = rds_config.db_username
password = rds_config.db_password
db_name = rds_config.db_name
logger = logging.getLogger()
logger.setLevel(logging.INFO)
try:
conn = pymysql.connect(rds_host, user=name, passwd=password, db=db_name,
connect_timeout=5)
except pymysql.MySQLError as e:
logger.error("ERROR: Unexpected error: Could not connect to MySQL instance.")
logger.error(e)
sys.exit()
logger.info("SUCCESS: Connection to RDS MySQL instance succeeded")

"""
This function fetches content from MySQL RDS instance
"""
item_count = 0
with conn.cursor() as cur:

cur.execute("create table Employee ( EmpID int NOT NULL, Name varchar(255) NOT
NULL, PRIMARY KEY (EmpID))")
cur.execute('insert into Employee (EmpID, Name) values(1, "Joe")')
cur.execute('insert into Employee (EmpID, Name) values(2, "Bob")')
cur.execute('insert into Employee (EmpID, Name) values(3, "Mary")')
conn.commit()
cur.execute("select * from Employee")
for row in cur:
item_count += 1
logger.info(row)
#print(row)
conn.commit()
return "Added %d items from RDS MySQL table" %(item_count)
Ejecutar pymysql.connect() fuera del controlador permite que la función reutilice la conexión a la base
de datos para un rendimiento mejor.
Un segundo archivo contiene información de conexión para la función.
Example rds config.py
#config file containing credentials for RDS MySQL instance

db_username = "username"
db_password = "password"
db_name = "ExampleDB"
Dependencias.
• pymysql: el código de la función de Lambda utiliza esta biblioteca para obtener acceso a la instancia de
MySQL (consulte PyMySQL).
Instale dependencias con Pip y cree un paquete de implementación. Para obtener instrucciones, consulte
271
S3

Cree la función de Lambda con el comando create-function. Puede encontrar los ID de la subred y el
ID de grupo de seguridad de su VPC predeterminada en la consola de Amazon VPC.
$ aws lambda create-function --function-name CreateTableAddRecordsAndRead --runtime

python3.8 \
--zip-file fileb://app.zip --handler app.handler \
--role arn:aws:iam::123456789012:role/lambda-vpc-role \
--vpc-config SubnetIds=subnet-0532bb6758ce7c71f,subnet-
d6b7fda068036e11f,SecurityGroupIds=sg-0897d5f549934c2fb

En este paso, invocará la función de Lambda manualmente utilizando el comando invoke. Cuando se
ejecuta la función de Lambda, realiza la consulta SELECT en la tabla Employee de la instancia de MySQL
de RDS e imprime los resultados (estos resultados también van a CloudWatch Logs).
1. Invoque la función de Lambda con el comando invoke.
$ aws lambda invoke --function-name CreateTableAddRecordsAndRead output.txt
2. Compruebe que la función de Lambda se ha ejecutado correctamente del modo siguiente:
• Revise el archivo output.txt.

• Revise los resultados en la consola de AWS Lambda.
• Verifique los resultados en CloudWatch Logs.
Ahora que ha creado una función de Lambda que tiene accede a una base de datos en la VPC,
puede hacer que la función se invoque en respuesta a eventos. Para obtener información acerca de la
configuración de orígenes de eventos y ver ejemplos, consulte Utilización de AWS Lambda con otros
servicios (p. 163).
Uso de AWS Lambda con Amazon S3

Puede utilizar Lambda para procesar notificaciones de eventos desde Amazon Simple Storage Service.
Amazon S3 puede enviar un evento a una función Lambda cuando se crea o elimina un objeto. Puede
configurar las opciones de notificación en un bucket y conceder a Amazon S3 permiso para invocar una
función en la política de permisos basada en recursos de la función.
Warning
Si la función de Lambda utiliza el mismo bucket que la activa, podría provocar la ejecución de la
función en un bucle. Por ejemplo, si el bucket activa una función cada vez que se carga un objeto
y la función carga un objeto en el bucket, la función se activa indirectamente a sí misma. Para
evitarlo, utilice dos buckets o configure el desencadenador para que solo se aplique a un prefijo
que se utiliza para los objetos entrantes.
Amazon S3 invoca la función de forma asíncrona (p. 101) con un evento que contiene detalles sobre el
objeto. En el siguiente ejemplo se muestra un evento que envió Amazon S3 cuando se cargó un paquete
de implementación en Amazon S3.
Example Evento de notificaciones de Amazon S3
272
Tutorial
"Records": [
{
"eventSource": "aws:s3",
"eventTime": "2019-09-03T19:37:27.192Z",
"eventName": "ObjectCreated:Put",
"userIdentity": {
"principalId": "AWS:AIDAINPONIXQXHT3IKHL2"
},
"requestParameters": {
"sourceIPAddress": "205.255.255.255"
},
"responseElements": {
"x-amz-request-id": "D82B88E5F771F645",
"x-amz-id-2":
"vlR7PnpV2Ce81l0PRw6jlUpck7Jo5ZsQjryTjKlc5aLWGVHPZLj5NeC6qMa0emYBDXOo6QBU0Wo="
},
"s3": {
"s3SchemaVersion": "1.0",
"configurationId": "828aa6fc-f7b5-4305-8584-487c791949c1",
"bucket": {
"name": "lambda-artifacts-deafc19498e3f2df",
"ownerIdentity": {
"principalId": "A3I5XTEXAMAI3E"
},
"arn": "arn:aws:s3:::lambda-artifacts-deafc19498e3f2df"
},
"object": {
"key": "b21b84d653bb07b05b1e6b33684dc11b",
"size": 1305107,
"eTag": "b21b84d653bb07b05b1e6b33684dc11b",
"sequencer": "0C0F6F405D6ED209E1"
}
}
}
]
}
Para invocar la función, Amazon S3 necesita permiso de la política basada en recursos (p. 37) de la
función. Al configurar un desencadenador de Amazon S3 en la consola de Lambda, esta modifica la
política basada en recursos para permitir a Amazon S3 invocar la función si el nombre del bucket y el ID
de cuenta coinciden. Si configura la notificación en Amazon S3, utilice la API de Lambda para actualizar
la política. También puede utilizar la API de Lambda para conceder permisos a otra cuenta o restringir el
permiso a un alias designado.
Si la función utiliza el SDK de AWS para administrar los recursos de Amazon S3, también necesita
permisos de Amazon S3 en su rol de ejecución (p. 33).
Temas
• Tutorial: uso de AWS Lambda con Amazon S3 (p. 273)
• Código de función de muestra de Amazon S3 (p. 280)
• Plantilla de AWS SAM para una aplicación de Amazon S3 (p. 286)
Tutorial: uso de AWS Lambda con Amazon S3

Supongamos que desea crear una miniatura para cada archivo que se carga en un bucket. Puede crear
una función de Lambda (CreateThumbnail) que Amazon S3 puede invocar cuando se crean objetos. El
código de la función de Lambda puede leer el objeto de imagen del bucket de origen y crear una imagen
en miniatura en el bucket de destino.
273
Tutorial
Al completar este tutorial, tendrá los siguientes recursos de Amazon S3, Lambda y IAM en su cuenta.
Recursos de Lambda
• Una función de Lambda.

• Una política de acceso asociada a la función de Lambda que da a Amazon S3 permiso para invocar la
función de Lambda.
Recursos de IAM
• Un rol de ejecución que da permisos que la función de Lambda necesita a través de la política de
permisos asociada a este rol.
Recursos de Amazon S3
• Un bucket de origen con una configuración de notificación que invoca la función de Lambda.
• Un bucket de destino donde la función guarda las imágenes modificadas.
Requisitos previos

this is output
274
Tutorial
Instale NPM para administrar las dependencias de la función.
El tutorial utiliza comandos de la CLI de AWS para crear e invocar la función de Lambda. Instale la CLI de
AWS y configúrela con sus credenciales de AWS

AWS.


• Permissions (Permisos): AWSLambdaExecute.
• Role name (Nombre de rol): lambda-s3-role.
La política AWSLambdaExecute tiene permisos que la función necesita para administrar objetos en
Amazon S3 y escribir registros a CloudWatch Logs.
Crear buckets y cargar un objeto de muestra

Siga los pasos para crear buckets y cargar un objeto.

2. Cree dos buckets. El nombre del bucket de destino debe ser source seguido de -resized.
donde source es el nombre del bucket que desea utilizar para el origen. Por ejemplo, mybucket y
mybucket-resized.
3. En el bucket de origen, cargue un objeto .jpg denominado HappyFace.jpg.
Al invocar la función de Lambda manualmente antes de conectarse a Amazon S3, debe pasar los datos
del evento de muestra a la función que especifica el bucket de origen, y HappyFace.jpg como objeto
recién creado, por lo que necesita crear este objeto de muestra primero.
El siguiente código de ejemplo recibe un evento de Amazon S3 y procesa el mensaje que contiene.
Modifica una imagen en el bucket de origen y guarda la salida en el bucket de destino.
Note
Para ver código de muestra en otros lenguajes, consulte Código de función de muestra de
Amazon S3 (p. 280).
Example index.js
// dependencies
const AWS = require('aws-sdk');
275
Tutorial
const util = require('util');

const sharp = require('sharp');
// get reference to S3 client

const s3 = new AWS.S3();
exports.handler = async (event, context, callback) => {
// Read options from the event parameter.

console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
const srcBucket = event.Records[0].s3.bucket.name;
// Object key may have spaces or unicode non-ASCII characters.
const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, "
"));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix.

const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported

const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Download the image from the S3 source bucket.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var origimage = await s3.getObject(params).promise();
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect
ratio.
const width = 200;
// Use the Sharp module to resize the image and save in a buffer.
try {
var buffer = await sharp(origimage.Body).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket

try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: buffer,
ContentType: "image"
};
276
Tutorial
const putResult = await s3.putObject(destparams).promise();
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +

' and uploaded to ' + dstBucket + '/' + dstKey);
};
Revise el código anterior y observe lo siguiente:
• La función conoce el nombre del bucket de origen y el nombre de la clave de objeto a partir de los datos
del evento que recibe como parámetros. Si el objeto es una imagen .jpg o .png, el código crea una
miniatura y la guarda en el bucket de destino.
• El código presupone que el bucket de destino existe y que su nombre es una concatenación del nombre
del bucket de origen seguido por la cadena -resized. Por ejemplo, si el bucket de origen identificado
en los datos del evento es examplebucket, el código presupone que existe un bucket de destino
denominado examplebucket-resized.
• Para generar el nombre de la clave de la miniatura que crea, el código utiliza la cadena resized-
seguida del nombre de la clave del objeto de origen. Por ejemplo, si la clave del objeto de origen es
sample.jpg, el código crea una objeto de miniatura cuya clave es resized-sample.jpg.
El paquete de implementación es un archivo .zip que contiene el código y las dependencias de la función
de Lambda.
Para crear un paquete de implementación
1. Guarde el código de la función como index.js en una carpeta denominada lambda-s3.

2. Instale la biblioteca Sharp con npm. Para Linux, utilice el siguiente comando.
lambda-s3$ npm install sharp
Para macOS, utilice el siguiente comando.
lambda-s3$ npm install --arch=x64 --platform=linux --target=12.13.0 sharp
Cuando realice este paso, tendrá la siguiente estructura de carpetas:
lambda-s3
|- index.js
|- /node_modules/sharp
# /node_modules/...
3. Cree un paquete de implementación con el código de la función y las dependencias.
lambda-s3$ zip -r function.zip .
• Cree una función de Lambda con el comando create-function.
$ aws lambda create-function --function-name CreateThumbnail \
277
Tutorial

--timeout 10 --memory-size 1024 \
--role arn:aws:iam::123456789012:role/lambda-s3-role
En el caso del parámetro del rol, sustituya la secuencia numérica por el ID de la cuenta de AWS. El
comando del ejemplo anterior especifica un tiempo de espera de 10 segundos como configuración de la
función. En función del tamaño de los objetos que cargue, es posible que necesite para aumentar el tiempo
de espera utilizando el siguiente comando de la AWS CLI.
$ aws lambda update-function-configuration --function-name CreateThumbnail --timeout 30

En este paso, invocará la función de Lambda de forma manual con los datos de un evento de muestra de
Amazon S3.
1. Guarde los siguientes datos del evento de muestra de Amazon S3 en un archivo denominado
inputFile.txt. Deberá actualizar el JSON proporcionando el nombre de sourcebucket y una
clave de objeto .jpg.
{
"Records":[
{
"eventSource":"aws:s3",
"awsRegion":"us-west-2",
"eventTime":"1970-01-01T00:00:00.000Z",
"eventName":"ObjectCreated:Put",
"userIdentity":{
"principalId":"AIDAJDPLRKLG7UEXAMPLE"
},
"sourceIPAddress":"127.0.0.1"
},
"responseElements":{
"x-amz-request-id":"C3D13FE58DE4C810",
"x-amz-id-2":"FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD"
},
"s3":{
"s3SchemaVersion":"1.0",
"configurationId":"testConfigRule",
"bucket":{
"name":"sourcebucket",
"ownerIdentity":{
"principalId":"A3NL1KOZZKExample"
},
"arn":"arn:aws:s3:::sourcebucket"
},
"object":{
"key":"HappyFace.jpg",
"size":1024,
"eTag":"d41d8cd98f00b204e9800998ecf8427e",
"versionId":"096fKKXTRTtl3on89fVO.nfljtsv6qko"
}
}
}
]
}
278
Tutorial
2. Ejecute el siguiente comando Lambda de la CLI de invoke para invocar la función. Tenga en
cuenta que el comando solicita la ejecución asíncrona. También puede invocarla de forma síncrona
especificando RequestResponse como valor del parámetro invocation-type.
$ aws lambda invoke --function-name CreateThumbnail --invocation-type Event \

--payload file://inputFile.txt outputfile.txt
3. Verifique que se crea la miniatura en el bucket de destino.
Configure Amazon S3 para publicar eventos

En este paso, añadirá la configuración restante, de manera que Amazon S3 pueda publicar eventos de
creación de objetos en AWS Lambda e invocar la función de Lambda. En este paso, hará lo siguiente:
• Añadir permisos a la política de acceso de la función de Lambda para permitir que Amazon S3 invoque
la función.
• Añadir la configuración de notificaciones al bucket de origen. En la configuración de notificaciones, debe
proporcionar lo siguiente:
• Tipo de evento para el que desea que Amazon S3 publique eventos. Para este tutorial, debe
especificar el tipo de evento s3:ObjectCreated:* con objeto de que Amazon S3 publique eventos
cuando se creen objetos.
• Función de Lambda que se debe invocar.
Para añadir permisos a la política de función.
1. Ejecute el siguiente comando add-permission de la CLI de Lambda para conceder a la entidad

principal del servicio de Amazon S3 (s3.amazonaws.com) permisos para realizar la acción
lambda:InvokeFunction. Tenga en cuenta únicamente que se concede permiso a Amazon S3
para invocar la función si se cumplen las siguientes condiciones:
• Se detecta un evento de creación de objeto en un bucket específico.

• El bucket es propiedad de su cuenta. Si elimina un bucket, es posible que otra cuenta cree un
bucket con el mismo ARN.
$ aws lambda add-permission --function-name CreateThumbnail --principal

s3.amazonaws.com \
--statement-id s3invoke --action "lambda:InvokeFunction" \
--source-arn arn:aws:s3:::sourcebucket \
--source-account account-id
2. Verifique la política de acceso de la función ejecutando el comando get-policy de la AWS CLI.
$ aws lambda get-policy --function-name CreateThumbnail
Añada la configuración de notificaciones al bucket de origen para solicitar a Amazon S3 que publique los
eventos de creación de objetos en Lambda.
Important
Este procedimiento configura el bucket para invocar su función cada vez que se crea un objeto en
él. Asegúrese de configurar esta opción solo en el bucket de origen y no cree objetos en el bucket
de origen a partir de la función que se activa. De lo contrario, su función podría causar que se
invoque continuamente en bucle (p. 272).
279
Código de muestra
Para configurar notificaciones

2. Elija el bucket de origen
3. Seleccione Properties.
4. Bajo Eventos, configure una notificación con las siguientes especificaciones.
• Nombre – lambda-trigger.
• Eventos – ObjectCreate (All)
• Enviar – Lambda function
• Lambda – CreateThumbnail
Para obtener más información sobre la configuración de eventos, consulte Habilitar notificaciones de
eventos en la Guía del usuario de la consola de Amazon Simple Storage Service.
Ahora puede probar la configuración como se indica a continuación:
1. Cargue objetos .jpg o .png en el bucket de origen mediante la consola de Amazon S3.
2. Verifique que se crea la miniatura en el bucket de destino mediante la función CreateThumbnail.
3. Ver registros en la consola de CloudWatch.
Código de función de muestra de Amazon S3

Temas
• Node.js 12.x (p. 280)
• Java 11 (p. 282)
• Python 3 (p. 285)
Node.js 12.x
Cambia el tamaño de una imagen en el bucket de origen y guarda la salida en el bucket de destino.
Example index.js
// dependencies
const AWS = require('aws-sdk');
const util = require('util');
const sharp = require('sharp');
// get reference to S3 client

const s3 = new AWS.S3();
exports.handler = async (event, context, callback) => {
// Read options from the event parameter.

console.log("Reading options from event:\n", util.inspect(event, {depth: 5}));
280
Código de muestra
const srcBucket = event.Records[0].s3.bucket.name;

const srcKey = decodeURIComponent(event.Records[0].s3.object.key.replace(/\+/g, "
"));
const dstBucket = srcBucket + "-resized";
const dstKey = "resized-" + srcKey;
// Infer the image type from the file suffix.

const typeMatch = srcKey.match(/\.([^.]*)$/);
if (!typeMatch) {
console.log("Could not determine the image type.");
return;
}
// Check that the image type is supported

const imageType = typeMatch[1].toLowerCase();
if (imageType != "jpg" && imageType != "png") {
console.log(`Unsupported image type: ${imageType}`);
return;
}
// Download the image from the S3 source bucket.
try {
const params = {
Bucket: srcBucket,
Key: srcKey
};
var origimage = await s3.getObject(params).promise();
} catch (error) {
console.log(error);
return;
}
// set thumbnail width. Resize will set the height automatically to maintain aspect
ratio.
const width = 200;
// Use the Sharp module to resize the image and save in a buffer.
try {
var buffer = await sharp(origimage.Body).resize(width).toBuffer();
} catch (error) {
console.log(error);
return;
}
// Upload the thumbnail image to the destination bucket

try {
const destparams = {
Bucket: dstBucket,
Key: dstKey,
Body: buffer,
ContentType: "image"
};
const putResult = await s3.putObject(destparams).promise();
} catch (error) {
console.log(error);
return;
}
console.log('Successfully resized ' + srcBucket + '/' + srcKey +

' and uploaded to ' + dstBucket + '/' + dstKey);
281
Código de muestra
};
El paquete de implementación es un archivo .zip que contiene el código y las dependencias de la función
de Lambda.
1. Cree una carpeta (examplefolder) y, a continuación, cree una subcarpeta (node_modules).

2. Instale las dependencias. Los ejemplos de código utilizan las siguientes bibliotecas:
• AWS SDK para JavaScript en Node.js

• Sharp para node.js
El tiempo de ejecución de AWS Lambda ya tiene el SDK para JavaScript de AWS en Node.js, por lo
que solo tiene que instalar la biblioteca Sharp. Abra un símbolo del sistema, vaya a examplefolder
e instale las bibliotecas utilizando el comando npm, que forma parte de Node.js. Para Linux, utilice el
siguiente comando.
$ npm install sharp
Para macOS, utilice el siguiente comando.
$ npm install --arch=x64 --platform=linux --target=12.13.0 sharp
3. Guarde el código de muestra en un archivo llamado index.js.

4. Revise el código anterior y observe lo siguiente:
• La función conoce el nombre del bucket de origen y el nombre de la clave de objeto a partir de los
datos del evento que recibe como parámetros. Si el objeto es una imagen .jpg, el código crea una
miniatura y la guarda en el bucket de destino.
• El código presupone que el bucket de destino existe y que su nombre es una concatenación del
nombre del bucket de origen seguido por la cadena -resized. Por ejemplo, si el bucket de origen
identificado en los datos del evento es examplebucket, el código presupone que existe un bucket
de destino denominado examplebucket-resized.
• Para generar el nombre de la clave de la miniatura que crea, el código utiliza la cadena resized-
seguida del nombre de la clave del objeto de origen. Por ejemplo, si la clave del objeto de origen es
sample.jpg, el código crea una objeto de miniatura cuya clave es resized-sample.jpg.
5. Guarde el archivo como index.js en examplefolder. Cuando realice este paso, tendrá la
siguiente estructura de carpetas:
index.js
/node_modules/sharp
6. Comprima el archivo index.js y la carpeta de módulos de nodo como CreateThumbnail.zip.
Java 11
A continuación, se muestra un ejemplo de código Java que lee los eventos entrantes de Amazon S3 y crea
una miniatura. Observe que implementa la interfaz RequestHandler proporcionada en la biblioteca aws-
lambda-java-core. Por lo tanto, en el momento de crear una función de Lambda debe especificar la
clase como controlador (es decir, example.handler). Para obtener más información acerca de cómo
utilizar interfaces para proporcionar un controlador, consulte Interfaces de controlador (p. 394).
282
Código de muestra
El tipo S3Event utilizado por el controlador como tipo de entrada es una de las clases predefinidas en la
biblioteca aws-lambda-java-events que proporciona métodos para que se pueda leer fácilmente la
información del evento entrante de Amazon S3. El controlador devuelve una cadena como salida.
Example Handler.java
package example;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.imageio.ImageIO;
import com.amazonaws.AmazonServiceException;
import com.amazonaws.services.lambda.runtime.events.S3Event;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.event.S3EventNotification.S3EventNotificationRecord;
import com.amazonaws.services.s3.model.GetObjectRequest;
import com.amazonaws.services.s3.model.ObjectMetadata;
import com.amazonaws.services.s3.model.S3Object;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
public class Handler implements

RequestHandler<S3Event, String> {
private static final float MAX_WIDTH = 100;
private static final float MAX_HEIGHT = 100;
private final String JPG_TYPE = (String) "jpg";
private final String JPG_MIME = (String) "image/jpeg";
private final String PNG_TYPE = (String) "png";
private final String PNG_MIME = (String) "image/png";
public String handleRequest(S3Event s3event, Context context) {

try {
S3EventNotificationRecord record = s3event.getRecords().get(0);
String srcBucket = record.getS3().getBucket().getName();

String srcKey = record.getS3().getObject().getUrlDecodedKey();
String dstBucket = srcBucket + "-resized";

String dstKey = "resized-" + srcKey;
// Sanity check: validate that source and destination are different

// buckets.
if (srcBucket.equals(dstBucket)) {
System.out
.println("Destination bucket must not match source bucket.");
return "";
}
// Infer the image type.

Matcher matcher = Pattern.compile(".*\\.([^\\.]*)").matcher(srcKey);
if (!matcher.matches()) {
System.out.println("Unable to infer image type for key "
283
Código de muestra
+ srcKey);
return "";
}
String imageType = matcher.group(1);
if (!(JPG_TYPE.equals(imageType)) && !(PNG_TYPE.equals(imageType))) {
System.out.println("Skipping non-image " + srcKey);
return "";
}
// Download the image from S3 into a stream

AmazonS3 s3Client = AmazonS3ClientBuilder.defaultClient();
S3Object s3Object = s3Client.getObject(new GetObjectRequest(
srcBucket, srcKey));
InputStream objectData = s3Object.getObjectContent();
// Read the source image

BufferedImage srcImage = ImageIO.read(objectData);
int srcHeight = srcImage.getHeight();
int srcWidth = srcImage.getWidth();
// Infer the scaling factor to avoid stretching the image
// unnaturally
float scalingFactor = Math.min(MAX_WIDTH / srcWidth, MAX_HEIGHT
/ srcHeight);
int width = (int) (scalingFactor * srcWidth);
int height = (int) (scalingFactor * srcHeight);
BufferedImage resizedImage = new BufferedImage(width, height,

BufferedImage.TYPE_INT_RGB);
Graphics2D g = resizedImage.createGraphics();
// Fill with white before applying semi-transparent (alpha) images
g.setPaint(Color.white);
g.fillRect(0, 0, width, height);
// Simple bilinear resize
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.drawImage(srcImage, 0, 0, width, height, null);
g.dispose();
// Re-encode image to target format

ByteArrayOutputStream os = new ByteArrayOutputStream();
ImageIO.write(resizedImage, imageType, os);
InputStream is = new ByteArrayInputStream(os.toByteArray());
// Set Content-Length and Content-Type
ObjectMetadata meta = new ObjectMetadata();
meta.setContentLength(os.size());
if (JPG_TYPE.equals(imageType)) {
meta.setContentType(JPG_MIME);
}
if (PNG_TYPE.equals(imageType)) {
meta.setContentType(PNG_MIME);
}
// Uploading to S3 destination bucket

System.out.println("Writing to: " + dstBucket + "/" + dstKey);
try {
s3Client.putObject(dstBucket, dstKey, is, meta);
}
catch(AmazonServiceException e)
{
System.err.println(e.getErrorMessage());
System.exit(1);
}
System.out.println("Successfully resized " + srcBucket + "/"
+ srcKey + " and uploaded to " + dstBucket + "/" + dstKey);
return "Ok";
} catch (IOException e) {
284
Código de muestra
throw new RuntimeException(e);

}
}
}
Amazon S3 invoca la función de Lambda mediante el tipo de invocación Event, en el que AWS Lambda
ejecuta el código de forma asíncrona. No importa lo que se devuelva. Sin embargo, en este caso estamos
implementando una interfaz que obliga a especificar un tipo de retorno, por lo que en este ejemplo el
controlador utiliza String como tipo de retorno.
Dependencias.
• aws-java-sdk
Java (p. 386).
Python 3
Modifica una imagen en el bucket de origen y guarda la salida en el bucket de destino.
Example lambda_function.py
import boto3
import os
import sys
import uuid
from urllib.parse import unquote_plus
from PIL import Image
import PIL.Image
s3_client = boto3.client('s3')
def resize_image(image_path, resized_path):

with Image.open(image_path) as image:
image.thumbnail(tuple(x / 2 for x in image.size))
image.save(resized_path)

bucket = record['s3']['bucket']['name']
key = unquote_plus(record['s3']['object']['key'])
tmpkey = key.replace('/', '')
download_path = '/tmp/{}{}'.format(uuid.uuid4(), tmpkey)
upload_path = '/tmp/resized-{}'.format(tmpkey)
s3_client.download_file(bucket, key, download_path)
resize_image(download_path, upload_path)
s3_client.upload_file(upload_path, '{}-resized'.format(bucket), key)
Note
La biblioteca de imágenes que este código utiliza debe instalarse en un entorno Linux para crear
un paquete de implementación que funcione.
285
1. Copie el código de muestra en un archivo con el nombre lambda_function.py.

2. Cree un entorno virtual.
s3-python$ virtualenv v-env

s3-python$ source v-env/bin/activate
3. Instale las bibliotecas en el entorno virtual.
(v-env) s3-python$ pip install Pillow boto3
4. Cree un paquete de implementación con el contenido de las bibliotecas instaladas.
(v-env) s3-python$ cd $VIRTUAL_ENV/lib/python3.8/site-packages

(v-env) python-s3/v-env/lib/python3.8/site-packages$ zip -r9 ${OLDPWD}/function.zip .
5. Agregue el código de controlador al paquete de implementación y desactive el entorno virtual.
(v-env) python-s3/v-env/lib/python3.8/site-packages$ cd ${OLDPWD}

(v-env) python-s3$ zip -g function.zip lambda_function.py
adding: lambda_function.py (deflated 55%)
(v-env) python-s3$ deactivate
Plantilla de AWS SAM para una aplicación de Amazon

S3
Resources:
CreateThumbnail:
Properties:
Handler: handler
Runtime: runtime
Timeout: 60
Policies: AWSLambdaExecute
Events:
CreateThumbnailEvent:
Type: S3
Properties:
Bucket: !Ref SrcBucket
Events: s3:ObjectCreated:*
SrcBucket:
286
Lote S3
Type: AWS::S3::Bucket
Uso de AWS Lambda con operaciones por lotes de

Amazon S3
Puede utilizar las operaciones por lotes de Amazon S3 para invocar una función Lambda en un conjunto
grande de objetos de Amazon S3. Amazon S3 realiza un seguimiento del progreso de las operaciones por
lotes, envía notificaciones y almacena un informe de finalización que muestra el estado de cada acción.
Para ejecutar una operación por lotes, cree untrabajo de operaciones por lotes de Amazon S3. Cuando se
crea el trabajo, se proporciona un manifiesto (la lista de objetos) y se configura la acción a realizar en esos
objetos.
Cuando se inicia el trabajo por lotes, Amazon S3 invoca la función Lambda sincrónicamente (p. 100) para
cada objeto del manifiesto. El parámetro de evento incluye los nombres del bucket y del objeto.
En el ejemplo siguiente se muestra el evento que Amazon S3 envía a la función Lambda de un objeto
denominado customerImage1.jpg en el bucket awsexamplebucket .
Example Evento de solicitud por lotes de Amazon S3
{
"invocationSchemaVersion": "1.0",
"invocationId": "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"job": {
"id": "f3cc4f60-61f6-4a2b-8a21-d07600c373ce"
},
"tasks": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
"s3Key": "customerImage1.jpg",
"s3VersionId": "1",
"s3BucketArn": "arn:aws:s3:us-east-1:0123456788:awsexamplebucket"
}
]
}
Su función Lambda debe devolver un objeto JSON con los campos tal como se muestran en el siguiente
ejemplo. Puede copiar el parámetro invocationId y taskId desde el parámetro de evento. Puede
devolver una cadena en el resultString. Amazon S3 guarda los valores resultString en el informe
de finalización.
Example Respuesta de solicitud por lotes de Amazon S3
{
"invocationSchemaVersion": "1.0",
"treatMissingKeysAs" : "PermanentFailure",
"invocationId" : "YXNkbGZqYWRmaiBhc2RmdW9hZHNmZGpmaGFzbGtkaGZza2RmaAo",
"results": [
{
"taskId": "dGFza2lkZ29lc2hlcmUK",
287
Invocación de funciones de Lambda desde
operaciones por lotes de Amazon S3
"resultCode": "Succeeded",
"resultString": "["Alice", "Bob"]"
}
]
}
Invocación de funciones de Lambda desde

operaciones por lotes de Amazon S3
Puede invocar la función Lambda con el ARN de una función no calificada o calificada. Si desea utilizar la
misma versión de una función para todo el trabajo por lotes, configure una versión de función específica
en el parámetro FunctionARN cuando cree el trabajo. Si configura un alias o el calificador $LATEST, el
trabajo por lotes comienza inmediatamente a llamar a la nueva versión de la función si el alias o $LATEST
se actualizan durante la ejecución del trabajo.
Tenga en cuenta que no puede reutilizar una función Amazon S3 basada en eventos existente para
operaciones por lotes. Esto se debe a que la operación por lotes de Amazon S3 pasa un parámetro de
evento diferente a la función Lambda y espera un mensaje de retorno con una estructura JSON específica.
En la política basada en recursos (p. 37) que cree para el trabajo por lotes de Amazon S3, asegúrese de
establecer permisos para que el trabajo invoque su función Lambda.
En el rol de ejecución (p. 33) de la función, establezca una política de confianza de Amazon S3 para
asumir el rol cuando ejecute la función.
Si su función utiliza SDK de AWS para administrar recursos de Amazon S3, debe agregar permisos de
Amazon S3 a la función de ejecución.
Cuando se ejecuta el trabajo, Amazon S3 inicia varias instancias de función para procesar los objetos de
Amazon S3 en paralelo, hasta el límite de concurrencia (p. 114) de la función. Amazon S3 limita el avance
inicial de instancias para evitar un costo excesivo para trabajos más pequeños.
Si la función Lambda devuelve un código de respuesta TemporaryFailure, Amazon S3 reintenta la

operación.
Para obtener más información acerca de las operaciones por lotes de Amazon S3, consulte Realización de
operaciones por lotes en la Guía para desarrolladores de Amazon S3.
Para obtener un ejemplo de cómo utilizar una función Lambda en operaciones por lotes de Amazon S3,
consulte Invocación de una función Lambda desde las operaciones por lotes de Amazon S3 en la Guía
para desarrolladores de Amazon S3.
Uso de AWS Lambda con Amazon SES

Si utiliza Amazon SES para recibir mensajes, puede configurar Amazon SES para que llame a una función
de Lambda cuando lleguen mensajes. El servicio puede invocar la función de Lambda pasándole como
parámetro el evento de correo electrónico entrante, que en realidad es un mensaje de Amazon SES en un
evento de Amazon SNS.
Example Evento de mensaje de Amazon SES
{
"Records": [
{
"ses": {
288
SES
"mail": {
"commonHeaders": {
"from": [
"Jane Doe <janedoe@example.com>"
],
"to": [
"johndoe@example.com"
],
"returnPath": "janedoe@example.com",
"messageId": "<0123456789example.com>",
"date": "Wed, 7 Oct 2015 12:34:56 -0700",
"subject": "Test Subject"
},
"source": "janedoe@example.com",
"timestamp": "1970-01-01T00:00:00.000Z",
"destination": [
],
"headers": [
{
"name": "Return-Path",
"value": "<janedoe@example.com>"
},
{
"name": "Received",
"value": "from mailer.example.com (mailer.example.com [203.0.113.1]) by
inbound-smtp.us-west-2.amazonaws.com with SMTP id o3vrnil0e2ic for johndoe@example.com;
Wed, 07 Oct 2015 12:34:56 +0000 (UTC)"
},
{
"name": "DKIM-Signature",
"value": "v=1; a=rsa-sha256; c=relaxed/relaxed; d=example.com;
s=example; h=mime-version:from:date:message-id:subject:to:content-type;
bh=jX3F0bCAI7sIbkHyy3mLYO28ieDQz2R0P8HwQkklFj4=; b=sQwJ+LMe9RjkesGu+vqU56asvMhrLRRYrWCbV"
},
{
"name": "MIME-Version",
"value": "1.0"
},
{
"name": "From",
"value": "Jane Doe <janedoe@example.com>"
},
{
"name": "Date",
"value": "Wed, 7 Oct 2015 12:34:56 -0700"
},
{
"name": "Message-ID",
"value": "<0123456789example.com>"
},
{
"name": "Subject",
"value": "Test Subject"
},
{
"name": "To",
"value": "johndoe@example.com"
},
{
"name": "Content-Type",
"value": "text/plain; charset=UTF-8"
}
],
"headersTruncated": false,
"messageId": "o3vrnil0e2ic28tr"
289
SNS
},
"receipt": {
"recipients": [
],
"timestamp": "1970-01-01T00:00:00.000Z",
"spamVerdict": {
"status": "PASS"
},
"dkimVerdict": {
"status": "PASS"
},
"processingTimeMillis": 574,
"action": {
"type": "Lambda",
"invocationType": "Event",
"functionArn": "arn:aws:lambda:us-west-2:012345678912:function:Example"
},
"spfVerdict": {
"status": "PASS"
},
"virusVerdict": {
"status": "PASS"
}
}
},
"eventSource": "aws:ses"
}
]
}
Para obtener más información, consulte Acción de Lambda en la Guía para desarrolladores de Amazon
SES.
Uso de AWS Lambda con Amazon SNS

Puede utilizar una función Lambda para procesar notificaciones de Amazon Simple Notification Service.
Amazon SNS admite funciones Lambda como destino para los mensajes enviados a un tema. Puede
suscribir la función a temas de la misma cuenta o de otras cuentas de AWS.
Amazon SNS invoca la función de forma asíncrona (p. 101) con un evento que contiene un mensaje y
metadatos.
Example Evento de mensaje de Amazon SNS
{
"Records": [
{
"EventVersion": "1.0",
"EventSubscriptionArn": "arn:aws:sns:us-east-2:123456789012:sns-lambda:21be56ed-
a058-49f5-8c98-aedd2564c486",
"EventSource": "aws:sns",
"Sns": {
"SignatureVersion": "1",
"Timestamp": "2019-01-02T12:45:07.000Z",
"SigningCertUrl": "https://sns.us-east-2.amazonaws.com/SimpleNotificationService-
ac565b8b1a6c5d002d285f9598aa1d9b.pem",
"Message": "Hello from SNS!",
"MessageAttributes": {
290
Tutorial
"Test": {
"Type": "String",
"Value": "TestString"
},
"TestBinary": {
"Type": "Binary",
"Value": "TestBinary"
}
},
"Type": "Notification",
"UnsubscribeUrl": "https://sns.us-east-2.amazonaws.com/?
Action=Unsubscribe&SubscriptionArn=arn:aws:sns:us-east-2:123456789012:test-
lambda:21be56ed-a058-49f5-8c98-aedd2564c486",
"TopicArn":"arn:aws:sns:us-east-2:123456789012:sns-lambda",
"Subject": "TestInvoke"
}
}
]
}
Para la invocación asíncrona, Lambda pone en cola el mensaje y gestiona los reintentos. Si Amazon
SNS no puede conectar con Lambda o el mensaje se rechaza, lo Amazon SNS reintenta la operación a
intervalos cada vez mayores durante varias horas. Para obtener más información, consulte Fiabilidad en
las preguntas frecuentes de Amazon SNS.
Para poder realizar entregas de Amazon SNS a Lambda entre distintas cuentas, debe autorizar la
invocación de la función de Lambda desde Amazon SNS. A su vez, Amazon SNS debe permitir que la
cuenta de Lambda se suscriba al tema de Amazon SNS. Por ejemplo, si el tema de Amazon SNS está en
la cuenta A y la función de Lambda está en la cuenta B, cada cuenta debe conceder permisos a la otra
para que acceda a sus recursos. Dado que en la consola de AWS no están disponibles todas las opciones
para configurar permisos entre cuentas, se utiliza la CLI de AWS para configurar todo el proceso.
Para obtener más información, consulte Invocación de funciones de Lambda mediante las notificaciones de
Amazon SNS en la Guía para desarrolladores de Amazon Simple Notification Service.
Temas
• Tutorial: uso de AWS Lambda con Amazon Simple Notification Service (p. 291)
Tutorial: uso de AWS Lambda con Amazon Simple

Notification Service
Puede utilizar una función de Lambda en una cuenta de AWS para suscribirse a un tema de Amazon
SNS de otra cuenta de AWS. En este tutorial, se utiliza la AWS Command Line Interface para realizar
operaciones de AWS Lambda, como, por ejemplo, la creación de una función de Lambda, la creación de
un tema de Amazon SNS y la concesión de permisos permitir que estos dos recursos puedan acceder el
uno al otro.
Requisitos previos
291
Tutorial

this is output
En el tutorial, se utilizarán dos cuentas. Los comandos de la AWS CLI ilustran esto utilizando dos perfiles
con nombre, cada uno configurado para el uso con una cuenta diferente. Si utiliza perfiles con nombres
distintos, bien el perfil predeterminado o un perfil con nombre, modifique los comandos según sea
necesario.
Crear un tema de Amazon SNS

Desde la cuenta A (01234567891A), cree el tema de Amazon SNS de origen.
$ aws sns create-topic --name lambda-x-account --profile accountA
Anote el ARN del tema que devuelve el comando. Lo necesitará cuando añada permisos a la función de
Lambda para suscribirse al tema.

Desde la cuenta B (01234567891B), cree el rol de ejecución (p. 33) que da a la función permiso para
acceder a los recursos de AWS.


• Role name (Nombre de rol): lambda-sns-role.

Crear una función de Lambda

Desde la cuenta B (01234567891B), cree la función que procesa los eventos desde Amazon SNS. A
continuación se muestra código de ejemplo que recibe un evento de Amazon SNS como entrada y procesa
Note
Example index.js
292
Tutorial

// console.log('Received event:', JSON.stringify(event, null, 4));
var message = event.Records[0].Sns.Message;

console.log('Message received from SNS:', message);
};

$ aws lambda create-function --function-name SNS-X-Account \

--role arn:aws:iam::01234567891B:role/service-role/lambda-sns-execution-role \
--timeout 60 --profile accountB
Anote el ARN de la función que devuelve el comando. Lo necesitará cuando añada permisos para permitir
a Amazon SNS que invoque la función.
Configuración de los permisos entre las cuentas

Desde la cuenta A (01234567891A), conceda permiso a la cuenta B (01234567891B) para suscribirse al
tema:
$ aws sns add-permission --label lambda-access --aws-account-id 12345678901B \

--topic-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--action-name Subscribe ListSubscriptionsByTopic Receive --profile accountA
Desde la cuenta B (01234567891B) añada el permiso de Lambda para permitir la invocación desde
Amazon SNS.
$ aws lambda add-permission --function-name SNS-X-Account \

--source-arn arn:aws:sns:us-east-2:12345678901A:lambda-x-account \
--statement-id sns-x-account --action "lambda:InvokeFunction" \
--principal sns.amazonaws.com --profile accountB
{
"Statement": "{\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":
\"arn:aws:lambda:us-east-2:12345678901B:function:SNS-X-Account\"}},
\"Action\":[\"lambda:InvokeFunction\"],
\"Resource\":\"arn:aws:lambda:us-east-2:01234567891A:function:SNS-X-Account\",
\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"sns.amazonaws.com\"},
\"Sid\":\"sns-x-account1\"}"
}
No utilice el parámetro --source-account para añadir una cuenta de origen a la política de Lambda al
añadir la política. La cuenta de origen no es compatible con los orígenes de eventos de Amazon SNS y
dará lugar a la denegación de acceso.
Note
Si la cuenta con el tema de SNS está alojada en una región de registro, debe especificar la
región en la entidad principal. Para ver un ejemplo, consulte Invocación de funciones de Lambda
293
Código de muestra
mediante las notificaciones de Amazon SNS en la Guía para desarrolladores de Amazon Simple
Notification Service.
Crear una suscripción

Desde la cuenta B, suscriba la función de Lambda al tema. Cuando se envía un mensaje al tema de
lambda-x-account en la cuenta A (01234567891A), Amazon SNS invoca la función SNS-X-Account
en la cuenta B (01234567891B).
$ aws sns subscribe --protocol lambda \

--notification-endpoint arn:aws:lambda:us-east-2:12345678901B:function:SNS-X-Account \
--profile accountB
{
"SubscriptionArn": "arn:aws:sns:us-east-2:12345678901A:lambda-x-
account:5d906xxxx-7c8x-45dx-a9dx-0484e31c98xx"
}
La salida contiene el ARN de la suscripción al tema.
Probar suscripción
Desde la cuenta A (01234567891A), pruebe la suscripción. Escriba Hello World en un archivo de texto y
guárdelo como message.txt. A continuación, ejecute el siguiente comando:
$ aws sns publish --message file://message.txt --subject Test \

--profile accountA
Esto devolverá un ID de mensaje con un identificador único que indica que el servicio Amazon SNS aceptó
el mensaje. A continuación, Amazon SNS intentará entregarlo a los suscriptores del tema. También puede
proporcionar una cadena JSON directamente al parámetro message, pero si utiliza un archivo de texto,
puede incluir saltos de línea en el mensaje.
Para obtener más información sobre Amazon SNS, consulte ¿Qué es Amazon Simple Notification Service?

Temas
• Node.js 8 (p. 294)
• Java 11 (p. 295)
• Go (p. 295)
• Python 3 (p. 296)
Node.js 8
En el siguiente ejemplo, se procesan los mensajes de Amazon SNS, y registra su contenido.
Example index.js
294
Código de muestra
// console.log('Received event:', JSON.stringify(event, null, 4));
var message = event.Records[0].Sns.Message;

console.log('Message received from SNS:', message);
};
Java 11
Example LambdaWithSNS.java
package example;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import com.amazonaws.services.lambda.runtime.events.SNSEvent;
public class LogEvent implements RequestHandler<SNSEvent, Object> {

public Object handleRequest(SNSEvent request, Context context){
String timeStamp = new SimpleDateFormat("yyyy-MM-
dd_HH:mm:ss").format(Calendar.getInstance().getTime());
context.getLogger().log("Invocation started: " + timeStamp);
context.getLogger().log(request.getRecords().get(0).getSNS().getMessage());
timeStamp = new SimpleDateFormat("yyyy-MM-

dd_HH:mm:ss").format(Calendar.getInstance().getTime());
context.getLogger().log("Invocation completed: " + timeStamp);
return null;
}
}
Dependencias.
Java (p. 386).
Go
Example lambda_handler.go
package main
import (
"context"
"fmt"
295
SQS
"github.com/aws/aws-lambda-go/lambda"
)
func handler(ctx context.Context, snsEvent events.SNSEvent) {

for _, record := range snsEvent.Records {
snsRecord := record.SNS
fmt.Printf("[%s %s] Message = %s \n", record.EventSource, snsRecord.Timestamp,
snsRecord.Message)
}
}
func main() {
lambda.Start(handler)
}
Python 3
Example lambda_handler.py

import json
print('Loading function')

#print("Received event: " + json.dumps(event, indent=2))
message = event['Records'][0]['Sns']['Message']
print("From SNS: " + message)
return message
Uso de AWS Lambda con Amazon SQS

Puede usar una función AWS Lambda para procesar mensajes en una cola Amazon Simple Queue Service
(Amazon SQS). Las asignaciones de origen de eventos (p. 109) de Lambda admiten colas estándar
y colas de primero en entrar, primero en salir (FIFO). Con Amazon SQS, puede descargar tareas de
un componente de su aplicación enviándolas a una cola para, a continuación, procesarlas de forma
asíncrona.
Lambda sondea la cola e invoca la función sincrónicamente (p. 100) con un evento que contenga
mensajes de cola. Lambda lee mensajes en lotes e invoca la función una vez por lote. Cuando la función
procesa correctamente un lote, Lambda elimina sus mensajes de la cola. En el ejemplo siguiente se
muestra un evento para un lote de dos mensajes.
Example Evento de mensaje de Amazon SQS (cola estándar)
{
"Records": [
{
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
296
SQS
"body": "Test message.",

"attributes": {
"ApproximateReceiveCount": "1",
"SentTimestamp": "1545082649183",
"SenderId": "AIDAIENQZJOLO23YVJ4VO",
"ApproximateFirstReceiveTimestamp": "1545082649185"
},
"messageAttributes": {},
"md5OfBody": "e4e68fb7bd0e697a0ae8f1bb342846b3",
"eventSource": "aws:sqs",
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"awsRegion": "us-east-2"
},
{
"messageId": "2e1424d4-f796-459a-8184-9c92662be6da",
"receiptHandle": "AQEBzWwaftRI0KuVm4tP+/7q1rGgNqicHq...",
"attributes": {
"SentTimestamp": "1545082650636",
},
}
]
}
Para las colas FIFO, los registros contienen atributos adicionales relacionados con la deduplicación y la
secuenciación.
Example Evento de mensaje de Amazon SQS (cola FIFO)
{
"Records": [
{
"messageId": "11d6ee51-4cc7-4302-9e22-7cd8afdaadf5",
"receiptHandle": "AQEBBX8nesZEXmkhsmZeyIE8iQAMig7qw...",
"attributes": {
"SentTimestamp": "1573251510774",
"SequenceNumber": "18849496460467696128",
"MessageGroupId": "1",
"SenderId": "AIDAIO23YVJENQZJOL4VO",
"MessageDeduplicationId": "1",
},
"eventSourceARN": "arn:aws:sqs:us-east-2:123456789012:fifo.fifo",
}
]
}
Cuando Lambda lee un lote, los mensajes se mantienen en la cola, pero se ocultan durante el tiempo de
espera de visibilidad de la cola. Cuando la función procesa correctamente un lote, Lambda elimina sus
297
Escalado y procesamiento
mensajes de la cola. Si la función se limita (p. 114), devuelve un error o no responde, el mensaje se hace
visible de nuevo. Todos los mensajes de un lote con errores volverán a la cola, por lo que el código de su
función debe ser capaz de procesar el mismo mensaje varias veces sin efectos secundarios.
Escalado y procesamiento
Para las colas estándar, Lambda utiliza el sondeo largo para sondear una cola hasta que se active.
Cuando los mensajes están disponibles, Lambda lee hasta 5 lotes y los envía a su función. Si los mensajes
siguen estando disponibles, Lambda aumenta el número de procesos que son lotes de lectura hasta 60
instancias más por minuto. El número máximo de lotes que se pueden procesar simultáneamente mediante
un mapeo de origen de eventos es 1000.
Para colas FIFO, Lambda envía mensajes a su función en el orden en que los recibe. Cuando se envía
un mensaje a una cola FIFO, se especifica un ID de grupo de mensajes. Amazon SQS garantiza que los
mensajes del mismo grupo se entreguen a Lambda en orden. Lambda ordena los mensajes en grupos y
envía sólo un lote a la vez por grupo. Si la función devuelve un error, todos los reintentos se realizan en los
mensajes afectados antes de que Lambda reciba mensajes adicionales del mismo grupo.
Su función puede escalar simultáneamente al número de grupos de mensajes activos. Para obtener más
información, consulte SQS FIFO como fuente de eventos en el blog de informática de AWS.
Configuración de una cola para el uso con Lambda

Cree una cola de SQS estándar que sirva como origen de eventos para la función de Lambda. A
continuación, configure la cola para dar tiempo a su función de Lambda a procesar cada lote de eventos—
y para que Lambda vuelva a actuar en respuesta a los errores de limitación a medida que aumenta.
Para dar tiempo al tiempo de función a procesar cada lote de registros, configure el tiempo de espera de
la visibilidad de la cola hasta al menos 6 veces el tiempo de espera (p. 54) que configure en su función. El
tiempo adicional permitirá a Lambda volver a intentar realizar los procesos en caso de que la ejecución de
la función se vea limitada debido al procesamiento de un lote anterior.
Si el procesamiento de un mensaje da error repetidas veces, Amazon SQS podrá enviar dicho mensaje a
una cola de mensajes fallidos. Cuando su función devuelve un error, Lambda lo deja en la cola. Después
de que se supera el tiempo de espera de visibilidad, Lambda recibe el mensaje de nuevo. Para enviar
mensajes a una segunda cola después de recibir varias veces, configure una cola de mensajes fallidos en
la cola de origen.
Note
Asegúrese de configurar la cola de mensajes fallidos en la cola de origen y no en la función de

Lambda. La cola de mensajes fallidos que configure en una función se utiliza para la cola de
invocación asíncrona (p. 101) de la función, no para las colas de origen de eventos.
Si la función devuelve un error o no puede invocarse porque está en la máxima simultaneidad, es

posible que el procesado tenga éxito tras algunos intentos adicionales. Para dar a los mensajes una
oportunidad mejor de ser procesados antes de enviarlos a la cola de mensajes fallidos, establezca el
maxReceiveCount de la política de redirección de la cola de origen a como mínimo 5.

Lambda necesita los permisos siguientes para poder administrar mensajes en la cola de Amazon SQS.
Añada dichos permisos al rol de ejecución de su función.
• sqs:ReceiveMessage
• sqs:DeleteMessage
• sqs:GetQueueAttributes
298
Configuración de una cola como origen de eventos
Para obtener más información, consulte Rol de ejecución de AWS Lambda (p. 33).
Configuración de una cola como origen de eventos

Cree un mapeo de origen de eventos para indicar a Lambda que envíe elementos desde una cola a una
función de Lambda. Puede crear varios mapeos de orígenes de eventos para procesar elementos de
varias colas con una sola función. Cuando Lambda invoca la función objetivo, el evento puede contener
múltiples elementos, dependiendo del tamaño de lote máximo configurable.
Para configurar la función para leer de Amazon SQS en la consola de Lambda, cree un desencadenador
de SQS.

Lambda admite las siguientes opciones para los orígenes de eventos de Amazon SQS.
• SQS queue (Cola de SQS): la cola de Amazon SQS desde la que leer registros.
• Batch size (Tamaño del lote): el número de elementos que leer de la cola en cada lote, hasta 10. El
evento podría contener menos elementos si el lote que Lambda lee de la cola tuviera menos elementos.
• Enabled (Habilitado): establecer en true para habilitar la asignación de origen de eventos. Establecer en
false para detener el procesamiento de registros.
Note
Amazon SQS tiene una capa gratuita permanente para las solicitudes. Más allá de la capa
gratuita, Amazon SQS cobra por cada millón de solicitudes. Mientras el mapeo de origen de
eventos está activa, Lambda realiza solicitudes a la cola para obtener elementos. Para obtener
más información sobre precios, consulte precios de Amazon Simple Queue Service.
Configure el tiempo de espera de la función para que disponga de tiempo suficiente para procesar todo
un lote de elementos. Si elementos tardan mucho tiempo en procesarse, elija un tamaño de lote más
pequeño. Un tamaño de lote amplio puede mejorar la eficiencia para cargas de trabajo que son muy
rápidas o tienen mucha administración. Sin embargo, si la función devuelve un error, todos los elementos
del lote vuelven a la cola. Si configura la simultaneidad reservada (p. 62) en la función, establezca al
menos 5 ejecuciones simultáneas para reducir la posibilidad de errores de límite cuando Lambda invoque
la función.


299
Tutorial

En el siguiente ejemplo se utiliza la AWS CLI para asignar una función llamada my-function a una cola
de Amazon SQS especificada mediante su nombre de recurso de Amazon (ARN), con un tamaño de lote
de 5.
$ aws lambda create-event-source-mapping --function-name my-function --batch-size 5 \

--event-source-arn arn:aws:sqs:us-east-2:123456789012:my-queue
{
"UUID": "2b733gdc-8ac3-cdf5-af3a-1827b3b11284",
"BatchSize": 5,
"EventSourceArn": "arn:aws:sqs:us-east-2:123456789012:my-queue",
"LastModified": 1541139209.351,
"StateTransitionReason": "USER_INITIATED"
}
Tutorial: uso de AWS Lambda con Amazon Simple

Queue Service
En este tutorial, debe crear una función de Lambda para consumir mensajes de una cola Amazon SQS.
Requisitos previos

this is output

AWS.

300
Tutorial
• Permissions (Permisos) – AWSLambdaSQSQueueExecutionRole.

• Role name (Nombre de rol): lambda-sqs-role.
La política AWSLambdaSQSQueueExecutionRole tiene permisos que la función necesita para leer

elementos de Amazon SQS y escribir registros a CloudWatch Logs.
A continuación se muestra código de ejemplo que recibe un evento de Amazon SQS como entrada y
procesa los mensajes que contiene. Con fines ilustrativos, el código escribe parte de los datos de los
Note
Para ver código de muestra en otros lenguajes, consulte Código de función de ejemplo de
Amazon SQS (p. 303).
Example index.js

event.Records.forEach(record => {
const { body } = record;
console.log(body);
});
return {};
}

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

--role arn:aws:iam::123456789012:role/lambda-sqs-role
Prueba de la función
Invoque la función de Lambda manualmente mediante el comando invoke de la CLI de AWS Lambda y
un evento de Amazon Simple Queue Service de muestra.
Si el controlador vuelve normalmente sin excepciones, Lambda considera que el mensaje se ha procesado
correctamente y empieza a leer nuevos mensajes en la cola. Una vez que un mensaje se procesa
correctamente, se elimina automáticamente de la cola. Si el controlador genera una excepción, Lambda
considera que la entrada de mensajes no se ha procesado e invoca de nuevo la función con el mismo lote
de mensajes.
{
"Records": [
{
301
Tutorial
"messageId": "059f36b4-87a3-44ab-83d2-661975830a7d",
"receiptHandle": "AQEBwJnKyrHigUMZj6rYigCgxlaS3SLy0a...",
"body": "test",
"attributes": {
"SentTimestamp": "1545082649183",
},
"md5OfBody": "098f6bcd4621d373cade4e832627b4f6",
}
]
}
2. Ejecute el siguiente comando invoke.
$ aws lambda invoke --function-name ProcessSQSRecord \

--payload file://input.txt outputfile.txt
3. Verifique la salida en el archivo outputfile.txt.
Creación de una cola de Amazon SQS

Cree una cola de Amazon SQS que la función de Lambda pueda utilizar como origen de eventos.
Para crear una cola
1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon SQS en https://
console.aws.amazon.com/sqs/.
2. En la consola de Amazon SQS, cree una cola.
3. Escriba o registre el ARN (nombre del recurso de Amazon) de la cola de identificación. Lo necesitará
en el siguiente paso al asociar la cola a la función Lambda.
Crear un mapeo de origen de eventos en AWS Lambda. Este mapeo de origen de eventos asocia la cola
de Amazon SQS a la función de Lambda. Una vez creado este mapeo de origen de eventos, AWS Lambda
comienza a sondear la cola.
Probar la experiencia integral. A medida que se actualiza la cola, Amazon Simple Queue Service escribe
mensajes en la cola. AWS Lambda sondea la cola, detecta nuevos registros y ejecuta la función de
Lambda en su nombre pasando los eventos a la función, en este caso mensajes de Amazon SQS.
Configuración del origen de eventos

Para crear un mapeo entre la cola de Amazon SQS especificada y la función de Lambda, ejecute el
comando create-event-source-mapping de la AWS CLI. Después de ejecutar el comando, anote
o registre el UUID. Necesitará este UUID para hacer referencia al mapeo de origen de eventos en otros
comandos, por ejemplo, si decide eliminar el mapeo de origen de eventos.
$ aws lambda create-event-source-mapping --function-name ProcessSQSRecord --batch-size 10

\
Para obtener la lista de mapeos de orígenes de eventos, ejecute el siguiente comando.
302
Código de muestra
$ aws lambda list-event-source-mappings --function-name ProcessSQSRecord \

La lista devuelve todos los mapeos de orígenes de eventos creados, y para cada uno de ellos muestra
el LastProcessingResult, entre otras cosas. Este campo se utiliza para proporcionar un mensaje
informativo en caso de que surja algún problema. Los valores como No records processed (indica
que AWS Lambda no ha comenzado el sondeo o que no hay registros en la cola) y OK (indica que AWS
Lambda ha leído correctamente los registros de la cola y ha invocado la función de Lambda) indican que
no hay ningún problema. Si hay algún problema, recibirá un mensaje de error.
Ahora puede probar la configuración como se indica a continuación:
1. En la consola de Amazon SQSpuede enviar mensajes a la cola. Amazon SQS escribe registros de estas
acciones en la cola.
2. AWS Lambda sondea la cola y, cuando detecta actualizaciones, invoca la función de Lambda pasando
los datos de eventos que encuentra en la cola.
3. La función ejecuta y crea logs en Amazon CloudWatch. Puede verificar los registros reportados en la
consola de Amazon CloudWatch.
Código de función de ejemplo de Amazon SQS

Temas
• Node.js (p. 303)
• Java (p. 304)
• C# (p. 304)
• Go (p. 305)
• Python (p. 306)
Node.js
A continuación se muestra código de ejemplo que recibe un mensaje de evento de Amazon SQS como
entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de entrada
en CloudWatch Logs.
Example index.js (Node.js 8)

const { body } = record;
console.log(body);
});
return {};
}
Example index.js (Node.js 6)
var body = record.body;
console.log(body);
303
Código de muestra
});
};
Java
A continuación se muestra código Java de ejemplo que recibe un mensaje de evento de Amazon SQS
como entrada y lo procesa. Con fines ilustrativos, el código escribe parte de los datos de los eventos de
En el código, handleRequest es el controlador. Este controlador utiliza la clase SQSEvent predefinida,

que se define en la biblioteca aws-lambda-java-events.
package example;
import com.amazonaws.services.lambda.runtime.events.SQSEvent;
import com.amazonaws.services.lambda.runtime.events.SQSEvent.SQSMessage;
public class Handler implements RequestHandler<SQSEvent, Void>{

@Override
public Void handleRequest(SQSEvent event, Context context)
{
for(SQSMessage msg : event.getRecords()){
System.out.println(new String(msg.getBody()));
}
return null;
}
}
Dependencias.
Java (p. 386).
C#
A continuación se muestra código C# de ejemplo que recibe un mensaje de evento de Amazon SQS como
en la consola.
En el código, handleRequest es el controlador. Este controlador utiliza la clase SQSEvent predefinida,

que se define en la biblioteca AWS.Lambda.SQSEvents.
Example ProcessingSQSRecords.cs
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
namespace SQSLambdaFunction
304
Código de muestra
{
public class SQSLambdaFunction
{
public string HandleSQSEvent(SQSEvent sqsEvent, ILambdaContext context)
{
Console.WriteLine($"Beginning to process {sqsEvent.Records.Count} records...");
foreach (var record in sqsEvent.Records)

{
Console.WriteLine($"Message ID: {record.MessageId}");
Console.WriteLine($"Event Source: {record.EventSource}");
Console.WriteLine($"Record Body:");
Console.WriteLine(record.Body);
}
Console.WriteLine("Processing complete.");
return $"Processed {sqsEvent.Records.Count} records.";

}
}
}
Go
A continuación se muestra código Go de ejemplo que recibe un mensaje de evento de Amazon SQS como
en CloudWatch Logs.
En el código, handler es el controlador. Este controlador utiliza la clase SQSEvent predefinida, que se
define en la biblioteca aws-lambda-go-events.
Example ProcessSQSRecords.go
package main
import (
"context"
"fmt"
)
func handler(ctx context.Context, sqsEvent events.SQSEvent) error {

for _, message := range sqsEvent.Records {
fmt.Printf("The message %s for event source %s = %s \n", message.MessageId,
message.EventSource, message.Body)
}
return nil
}
func main() {
lambda.Start(handler)
}
305
Python
A continuación se muestra código de ejemplo de Python que acepta un registro de Amazon SQS como
en CloudWatch Logs.
Siga las instrucciones para crear un paquete de implementación para la función de AWS Lambda.
Example ProcessSQSRecords.py

print ("test")
payload=record["body"]
print(str(payload))
Plantilla de AWS SAM para una aplicación de Amazon

SQS
Description: Example of processing messages on an SQS queue with Lambda
Resources:
MySQSQueueFunction:
Properties:
Runtime: nodejs12.x
Events:
MySQSEvent:
Type: SQS
Properties:
Queue: !GetAtt MySqsQueue.Arn
BatchSize: 10
MySqsQueue:
Type: AWS::SQS::Queue
306
Step Functions
Organizar funciones Lambda con AWS Step

Functions
Puede utilizar AWS Step Functions para crear máquinas de estado que organicen funciones Lambda
para crear una aplicación. Step Functions administra el estado de la aplicación y proporciona una interfaz
visual para definir flujos de trabajo que implican funciones Lambda, trabajos de AWS Batch, temas de
Amazon SNS, colas de Amazon SQS y otros recursos de AWS comunes. En lugar de definir la lógica de
la aplicación en un programa, se montan componentes de forma visual o con un lenguaje estructurado
basado en JSON llamado Lenguaje de estados de Amazon. Las funciones Lambda en Step Functions son
servicios autónomos y reutilizables con una interfaz bien definida que se puede compartir con usuarios
menos técnicos.
Step Functions invoca su función con un documento de evento que defina. Puede crear un estado de tarea
que invoque su función con la entrada a la máquina de estado o cualquier documento JSON.
Example event.json: entrada a la función de error aleatorio (p. 323)
{
"max-depth": 10,
"current-depth": 0,
"error-rate": 0.05
}
Step Functions facilita volver a intentar ejecuciones que producen error (p. 308) o ramificar la lógica de la
aplicación en función del resultado de una invocación.
Secciones
• Configuración de una máquina de estado como un origen de eventos (p. 307)
• Gestión de errores de función y servicio (p. 308)
Configuración de una máquina de estado como un

origen de eventos
Puede usar la consola de Step Functions para generar un estado que invoque una función Lambda o
definir estados directamente en JSON. En el ejemplo siguiente se muestra un estado de tarea que invoca
la versión 1 de una función denominada my-function con una carga de evento que tiene tres claves.
Cuando la función devuelve una respuesta correcta, la máquina de estado continúa con la siguiente tarea.
Example tarea de máquina de estado
"Invoke": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"FunctionName": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
"Payload": {
"max-depth": 10,
"current-depth": 0,
"error-rate": 0.05
}
},
"Next": "NEXT_STATE",
307
Gestión de errores de función y servicio
"TimeoutSeconds": 25
}
Permisos
Su máquina de estado necesita permiso para llamar a la API de Lambda para invocar una función.
Para concederle permiso, agregue la política administrada AWSLambdaRole o una política
insertada con ámbito de función en su rol. Para obtener más información, consulte Cómo funciona
AWS Step Functions con IAM en la Guía para desarrolladores de AWS Step Functions.
Los parámetros FunctionName y Payload mapean a los parámetros de la operación de la API

Invocar (p. 587). Además de estos, también puede especificar los parámetros InvocationType y
ClientContext. Por ejemplo, para invocar la función de forma asíncrona y continuar al siguiente estado
sin esperar un resultado, puede establecer InvocationType en Event según se muestra a continuación:
"InvocationType": "Event"
En lugar de codificar de forma rígida la carga del evento en la definición de máquina de estado, puede
usar la entrada de la ejecución de la máquina de estado. En el ejemplo siguiente se utiliza la entrada
especificada cuando ejecuta la máquina de estado como carga del evento:
"Payload.$": "$"
También puede invocar una función de forma asíncrona y esperar a que realice una
devolución de llamada con AWS SDK. Para ello, establezca el recurso del estado en
arn:aws:states:::lambda:invoke.waitForTaskToken. Para obtener más información, consulte
Invocar Lambda con Step Functions en la Guía para desarrolladores de AWS Step Functions.
Gestión de errores de función y servicio

Cuando su función o el servicio de Lambda devuelve un error, puede volver a intentar la invocación o
continuar en un estado diferente en función del tipo de error.
En el ejemplo siguiente se muestra una tarea de invocación que reintenta las excepciones de la API de
Lambda en la serie 5XX (ServiceException), los aceleradores (TooManyRequestsException),
los errores de tiempo de ejecución (Lambda.Unknown) y un error definido por función denominado
function.MaxDepthError. También captura un error llamado function.DoublesRolledError y
continúa a un estado llamado CaughtException cuando se produce.
Example invocar tarea: Reintentar y capturar
"Invoke": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Retry": [
{
"ErrorEquals": [
"function.MaxDepthError",
"Lambda.TooManyRequestsException",
"Lambda.ServiceException",
"Lambda.Unknown"
],
"MaxAttempts": 5
}
],
"Catch": [
{
"ErrorEquals": [ "function.DoublesRolledError" ],
308
"Next": "CaughtException"
}
],
"Parameters": {
"FunctionName": "arn:aws:lambda:us-east-2:123456789012:function:my-function:1",
...
Para capturar o volver a intentar errores de función, cree un tipo de error personalizado. El nombre
del tipo de error debe coincidir con errorType de la respuesta de error con formato que Lambda
devuelve cuando se genera un error. Para obtener detalles sobre cómo generar errores en cada lenguaje
compatible, consulte los temas siguientes:

Para obtener más información sobre la gestión de errores en Step Functions, consulte Control de las
condiciones de error con una máquina de estado de Step Functions en la Guía para desarrolladores de
AWS Step Functions.

Puede crear una aplicación sin servidor que incluya una máquina de estado de Step Functions en una
plantilla de AWS CloudFormation con Modelo de aplicación sin servidor de AWS (AWS SAM). Con AWS
SAM, puede definir la máquina de estado incorporada en la plantilla o en un archivo independiente. En el
siguiente ejemplo se muestra una máquina de estado que demuestra la invocación de una función Lambda
y la gestión de errores. Se refiere a un recurso de función definido en la misma plantilla (no se muestra).
Description: An AWS Lambda application that uses AWS Step Functions.
Resources:
statemachine:
Type: AWS::Serverless::StateMachine
Properties:
DefinitionSubstitutions:
FunctionArn: !GetAtt function.Arn
Payload: |
{
"max-depth": 5,
"current-depth": 0,
"error-rate": 0.2
}
Definition:
StartAt: Invoke
States:
Invoke:
Type: Task
Resource: arn:aws:states:::lambda:invoke
Parameters:
FunctionName: "${FunctionArn}"
Payload: "${Payload}"
309
InvocationType: Event
Retry:
- ErrorEquals:
- function.MaxDepthError
- function.MaxDepthError
- Lambda.TooManyRequestsException
- Lambda.ServiceException
- Lambda.Unknown
IntervalSeconds: 1
MaxAttempts: 5
Catch:
- ErrorEquals:
- function.DoublesRolledError
Next: CaughtException
- ErrorEquals:
- States.ALL
Next: UncaughtException
Next: Success
CaughtException:
Type: Pass
Result: The function returned an error.
End: true
UncaughtException:
Type: Pass
Result: Invocation failed.
End: true
Success:
Type: Pass
Result: Invocation succeeded!
End: true
Events:
scheduled:
Type: Schedule
Properties:
Description: Run every minute
Schedule: rate(1 minute)
Type: STANDARD
Policies:
- AWSLambdaRole
...
Esto crea una máquina de estado con la siguiente estructura:
310
X-Ray
Uso de AWS Lambda con AWS X-Ray

Puede utilizar AWS X-Ray para visualizar los componentes de la aplicación, identificar cuellos de botella
de rendimiento y solucionar problemas de solicitudes que dieron lugar a un error. Sus funciones Lambda
envían datos de rastreo a X-Ray y X-Ray procesa los datos para generar un mapa de servicio y resúmenes
de rastreo en los que se puede buscar.
Si ha habilitado el rastreo de X-Ray en un servicio que invoca su función, Lambda envía rastreos a X-
Ray automáticamente. El servicio ascendente, como Amazon API Gateway, o una aplicación alojada en
Amazon EC2 que está instrumentada con el SDK de X-Ray, muestra las solicitudes entrantes y agrega un
encabezado de rastreo que indica Lambda que envíe rastreos o no.
Para rastrear solicitudes que no tienen un encabezado de rastreo, habilite el rastreo activo en la
Para habilitar el rastreo activo

3. En AWS X-Ray, elija Active tracing (Rastreo activo).
Precios
X-Ray tiene una capa gratuita permanente Más allá del umbral de la capa gratuita, X-Ray realiza
cargos por almacenamiento y recuperación del seguimiento. Consulte Precios de AWS X-Ray
para obtener más información.
Su función necesita permiso para cargar datos de rastreo en X-Ray. Cuando habilita el rastreo activo en la
Lambda consola, Lambda agrega los permisos necesarios al rol de ejecución (p. 33) de la función. De lo
contrario, agregue la política AWSXRayDaemonWriteAccess al rol de ejecución.
X-Ray aplica un algoritmo de muestreo para garantizar que el rastreo sea eficiente, al tiempo que
proporciona una muestra representativa de las solicitudes a las que sirve la aplicación. La regla de
muestreo predeterminada es 1 solicitud por segundo y un 5 por ciento de las solicitudes adicionales.
311
En X-Ray, un seguimiento registra información sobre una solicitud procesada por uno o varios servicios.
Los servicios registran segmentos que contienen capas de subsegmentos. Lambda registra un segmento
para el servicio de Lambda que maneja la solicitud de invocación y otro para el trabajo realizado por
la función. El segmento de función viene con subsegmentos para Initialization, Invocation y
Overhead.
En el ejemplo siguiente se muestra un seguimiento con 2 segmentos. Ambos se llaman my-function, pero
uno es tipo AWS::Lambda y el otro es AWS::Lambda::Function. El segmento de función se expande
para mostrar sus subsegmentos.
Important
En Lambda, puede usar el SDK de X-Ray para extender el subsegmento Invocation con
subsegmentos adicionales para llamadas descendentes, anotaciones y metadatos. No se
puede acceder al segmento de función directamente o grabar trabajo hecho fuera del ámbito de
invocación del controlador.
Consulte los siguientes temas para obtener una introducción específica del seguimiento en Lambda:
• Instrumentación del código Node.js en AWS Lambda (p. 344)

• Instrumentación del código Python en AWS Lambda (p. 361)
• Instrumentación del código Ruby en AWS Lambda (p. 378)
• Instrumentación del código Java en AWS Lambda (p. 409)
• Instrumentación del código Go en AWS Lambda (p. 427)
• Instrumentación de código C# en AWS Lambda (p. 450)
Para obtener una lista completa de los servicios que admiten instrumentación activa, consulte Servicios de
AWS admitidos en la Guía para desarrolladores de AWS X-Ray.
Secciones
• El demonio de AWS X-Ray (p. 313)
• Habilitación del seguimiento activo con la API de Lambda (p. 313)
• Habilitación del seguimiento activo con AWS CloudFormation (p. 313)

Lambda necesita los siguientes permisos para enviar datos de seguimiento a X-Ray. Añada dichos
permisos al rol de ejecución (p. 33) de su función.
• xray:PutTraceSegments
312
El demonio de AWS X-Ray
• xray:PutTelemetryRecords
Estos permisos se incluyen en la política administrada AWSXRayDaemonWriteAccess .
El demonio de AWS X-Ray

En lugar de enviar datos de seguimiento directamente a la API X-Ray, el SDK de X-Ray utiliza un proceso
de demonio. El demonio de AWS X-Ray es una aplicación que se ejecuta en el entorno de Lambda y
escucha el tráfico UDP que contiene segmentos y subsegmentos. Almacena en búfer los datos entrantes
y los escribe en X-Ray en lotes, lo que reduce la sobrecarga de procesamiento y memoria necesaria para
rastrear las invocaciones.
El tiempo de ejecución de Lambda permite al demonio hasta un 3 por ciento de la memoria configurada de
su función o 16 MB, lo que sea mayor. Si su función se queda sin memoria durante la invocación, el tiempo
de ejecución termina el proceso del demonio primero para liberar memoria.
Para obtener más información, consulte El demonio de X-Ray en la Guía para desarrolladores de X-Ray.
Habilitación del seguimiento activo con la API de

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

El siguiente comando de la AWS CLI de ejemplo habilita el rastreo activo en una función llamada «my-
function».

--tracing-config Mode=Active
El modo de seguimiento forma parte de la configuración específica de la versión, que se bloquea cuando
se publica una versión de la función. No se puede cambiar el modo de seguimiento de una versión
publicada.
Habilitación del seguimiento activo con AWS

CloudFormation
Para habilitar el seguimiento activo en un recurso de AWS::Lambda::Function de una plantilla de AWS
CloudFormation, utilice la propiedad TracingConfig.
Example function-inline.yml: configuración de seguimiento
Resources:
function:
Type: AWS::Lambda::Function
Properties:
TracingConfig:
Mode: Active
313
Habilitación del seguimiento
activo con AWS CloudFormation
...
Para un recurso AWS::Serverless::Function de Modelo de aplicación sin servidor de AWS (AWS

SAM) , utilice la propiedad Tracing.
Example template.yml: configuración de seguimiento
Resources:
function:
Properties:
Tracing: Active
...
314
Aplicaciones de muestra de Lambda

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso de
diferentes lenguajes y servicios de AWS. Cada una de las aplicaciones de ejemplo contiene scripts para
facilitar la implementación y la limpieza, una plantilla de AWS SAM y recursos de soporte.
Node.js
Aplicaciones de Lambda de ejemplo en Node.js
• blank-nodejs: una función de Node.js que muestra el uso de registro, las variables de entorno, el
seguimiento de AWS X-Ray, las capas, las pruebas de unidad y el SDK de AWS.
• nodejs-apig: una función con un punto de enlace de API público que procesa un evento desde API
Gateway y devuelve una respuesta HTTP.
• rds-mysql: una función que transmite consultas a una base de datos MySQL para RDS. Este
ejemplo incluye una VPC privada y una instancia de base de datos configurada con una contraseña
en AWS Secrets Manager.
• 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.
• list-manager: una función procesa eventos de un flujo de datos de Amazon Kinesis y actualiza listas
agregadas en Amazon DynamoDB. La función almacena un registro de cada evento en una base de
datos MySQL for RDS en una VPC privada. Este ejemplo incluye una VPC privada con un punto de
enlace de la VPC para DynamoDB y una instancia de base de datos.
• error-processor: una función Node.js genera errores para un porcentaje especificado de solicitudes.
Una suscripción de CloudWatch Logs invoca una segunda función cuando se registra un error.
La función de procesador utiliza el SDK de AWS para recopilar detalles sobre la solicitud y
almacenarlos en un bucket de Amazon S3.
Python
Aplicaciones de Lambda de ejemplo en Python
• blank-python: una función de Python que muestra el uso del registro, las variables de entorno, el
seguimiento de AWS X-Ray, las capas, las pruebas unitarias y el SDK de AWS.
Ruby
Aplicaciones de Lambda de ejemplo en Ruby
• blank-ruby: una función de Ruby que muestra el uso del registro, las variables de entorno, el
seguimiento de AWS X-Ray, las pruebas de unidad y el SDK de AWS.
Java
Aplicaciones de Lambda de ejemplo en Java
• blank-java: función de Java que muestra el uso de bibliotecas de Java de Lambda, el registro, las
variables de entorno, las capas, el seguimiento de AWS X-Ray, las pruebas unitarias y el SDK de
AWS.
315
Función en blanco
• java-basic: función de Java mínima con pruebas unitarias y configuración de registro de variables.
• java-events: función de Java mínima que utiliza la biblioteca aws-lambda-java-events (p. 386) con
tipos de eventos que no requieren el SDK de AWS como dependencia, como Amazon API Gateway.
• java-events-v1sdk: función de Java que utiliza la biblioteca aws-lambda-java-events (p. 386)
con tipos de eventos que requieren el SDK de AWS como dependencia (Amazon Simple Storage
Service, Amazon DynamoDB y Amazon Kinesis).
• s3-java: función de Java que procesa los eventos de notificación de Amazon S3 y utiliza Java Class
Library (JCL) para crear miniaturas de los archivos de imagen cargados.
Go
Aplicaciones de Lambda de ejemplo en Go
• blank-go: una función de Go que muestra el uso de las bibliotecas de Go de Lambda, el registro, las
variables de entorno y el SDK de AWS.
C#
Aplicaciones de Lambda de muestra en C#
• blank-csharp: una función de C# que muestra el uso de las bibliotecas de .NET de Lambda, el
registro, las variables de entorno, el seguimiento de AWS X-Ray, las pruebas de unidad y el SDK de
AWS.
• ec2-spot: una función que administra las solicitudes de instancia de spot en Amazon EC2.
PowerShell
Aplicaciones de Lambda de ejemplo en PowerShell
• blank-powershell: una función de PowerShell que muestra el uso de registro, las variables de
entorno y el SDK de AWS.
Para implementar una aplicación de ejemplo, siga las instrucciones de su archivo README. Para obtener
más información sobre la arquitectura y los casos de uso de una aplicación, lea los temas de este capítulo.
Temas
• Aplicación de ejemplo de función en blanco para AWS Lambda (p. 316)
• Aplicación de ejemplo de procesamiento de errores para AWS Lambda (p. 323)
• Aplicación de ejemplo de List manager para AWS Lambda (p. 327)
Aplicación de ejemplo de función en blanco para

AWS Lambda
La aplicación de ejemplo de función en blanco es una aplicación de inicio que demuestra operaciones
comunes en Lambda con una función que llama a la API de Lambda. Muestra el uso del registro, las
variables de entorno, el seguimiento de AWS X-Ray, las capas, las pruebas de unidad y el SDK de AWS.
Explore esta aplicación para aprender acerca de la creación de funciones de Lambda en su lenguaje de
programación o úselo como punto de partida para sus propios proyectos.
316
Arquitectura y código de controlador
Las variantes de esta aplicación de ejemplo están disponibles para los siguientes idiomas:
Variantes
• Node.js: blank-nodejs.
• Python: blank-python.
• Ruby: blank-ruby.
• Java: blank-java.
• Go: blank-go.
• C#: blank-csharp.
• PowerShell: blank-powershell.
Los ejemplos de este tema resaltan el código de la versión Node.js, pero los detalles son generalmente
aplicables a todas las variantes.
Puede implementar el ejemplo en unos minutos con la AWS CLI y con AWS CloudFormation. Siga las
instrucciones del archivo README para descargarla, configurarla e implementarla en su cuenta.
Secciones
• Arquitectura y código de controlador (p. 317)
• Automatización de implementación con AWS CloudFormation y la AWS CLI (p. 318)
• Instrumentación con el AWS X-Ray (p. 321)
• Administración de dependencias con capas (p. 322)
Arquitectura y código de controlador

La aplicación de ejemplo consta de un código de función, una plantilla de AWS CloudFormation y recursos
auxiliares. Al implementar el ejemplo, utiliza los siguientes servicios de AWS:
• AWS Lambda: ejecuta el código de la función, envía los registros de CloudWatch Logs y envía los datos
de rastreo a X-Ray. La función también llama a la API de Lambda para obtener detalles sobre las cuotas
y el uso de la cuenta en la región actual.
• AWS X-Ray: recopila datos de rastreo, indexa los rastros para las búsquedas y genera un mapa de
servicio.
• Amazon CloudWatch: almacena registros y métricas.
• AWS Identity and Access Management (IAM): otorga el permiso.
• Amazon Simple Storage Service(Amazon S3): almacena el paquete de implementación de la función
durante la implementación.
• AWS CloudFormation: crea los recursos de la aplicación e implementa el código de la función.
317
Automatización de implementación con
AWS CloudFormation y la AWS CLI
Se aplican cargos estándar por cada servicio. Para obtener más información, consulte Precios de AWS.
El código de función muestra un flujo de trabajo básico para procesar un evento. El controlador toma un
evento de Amazon Simple Queue Service (Amazon SQS) como entrada e itera a través de los registros
que contiene, registrando el contenido de cada mensaje. Registra el contenido del evento, el objeto
de contexto y las variables de entorno. Luego realiza una llamada con el SDK de AWS y devuelve la
respuesta al tiempo de ejecución de Lambda.
Example blank-nodejs/function/index.js: código de controlador
// Handler
console.log(record.body)
})
console.log('## ENVIRONMENT VARIABLES: ' + serialize(process.env))
console.log('## CONTEXT: ' + serialize(context))
console.log('## EVENT: ' + serialize(event))
return getAccountSettings()
}
// Use SDK client

var getAccountSettings = function(){
return lambda.getAccountSettings().promise()
}
var serialize = function(object) {

return JSON.stringify(object, null, 2)
}
Los tipos de entrada/salida para el controlador y el soporte para la programación asíncrona varían según
el tiempo de ejecución. En este ejemplo, el método del controlador es async, por lo que en Node.js esto
implica que debe devolver una promesa al tiempo de ejecución. El tiempo de ejecución de Lambda espera
a que se resuelva la promesa y devuelve la respuesta al invocador. Si el código de función o el SDK de
AWS del cliente devuelven un error, el tiempo de ejecución formatea el error en un documento JSON y lo
devuelve.
La aplicación de ejemplo no incluye una cola de Amazon SQS para enviar eventos, pero usa un evento de
Amazon SQS (event.json) para ilustrar cómo se procesan los eventos. Para agregar una cola de Amazon
SQS a la aplicación, consulte Uso de AWS Lambda con Amazon SQS (p. 296).
Automatización de implementación con AWS

CloudFormation y la AWS CLI
Los recursos de la aplicación de ejemplo se definen en una plantilla de AWS CloudFormation y se
implementan con la AWS CLI. El proyecto incluye scripts de shell simples que automatizan el proceso de
configuración, implementación, invocación y desmantelamiento de la aplicación.
318
La plantilla de aplicación utiliza un tipo de recurso Modelo de aplicación sin servidor de AWS (AWS
SAM) para definir el modelo. AWS SAM simplifica la creación de plantillas para aplicaciones sin servidor
automatizando la definición de roles de ejecución, API y otros recursos.
La plantilla define los recursos de la pila de aplicaciones. Esto incluye la función, su rol de ejecución y una
capa de Lambda que proporciona las dependencias de biblioteca de la función. La pila no incluye el bucket
que AWS CLI utiliza durante la implementación o el grupo de registro de CloudWatch Logs.
Example blank-nodejs/template.yml: recursos sin servidor
Resources:
function:
Properties:
Runtime: nodejs12.x
CodeUri: function/.
Timeout: 10
Policies:
Tracing: Active
Layers:
- !Ref libs
libs:
Properties:
319
ContentUri: lib/.
CompatibleRuntimes:
- nodejs12.x
Al implementar la aplicación, AWS CloudFormation aplica la transformación AWS SAM a la plantilla para
generar una plantilla de AWS CloudFormation con tipos estándar como AWS::Lambda::Function y
AWS::IAM::Role.
Example plantilla procesada
{
"AWSTemplateFormatVersion": "2010-09-09",
"Description": "An AWS Lambda application that calls the Lambda API.",
"Resources": {
"function": {
"Type": "AWS::Lambda::Function",
"Properties": {
"Layers": [
{
"Ref": "libs32xmpl61b2"
}
],
"TracingConfig": {
"Mode": "Active"
},
"Code": {
"S3Bucket": "lambda-artifacts-6b000xmpl1e9bf2a",
"S3Key": "3d3axmpl473d249d039d2d7a37512db3"
},
"Description": "Call the AWS Lambda API",
"Tags": [
{
"Value": "SAM",
"Key": "lambda:createdBy"
}
],
En este ejemplo, la propiedad Code especifica un objeto en un bucket de Amazon S3. Esto corresponde a
la ruta local de la propiedad CodeUri en la plantilla de proyecto:
CodeUri: function/.
Para cargar los archivos de proyecto en Amazon S3, el script de implementación utiliza los comandos
de la AWS CLI. El comando cloudformation package preprocesa la plantilla, carga artefactos y
reemplaza rutas locales por ubicaciones de objetos de Amazon S3. El comando cloudformation
deploy implementa la plantilla procesada con un conjunto de cambios de AWS CloudFormation.
Example blank-nodejs/3-deploy.sh: paquete e implementación
#!/bin/bash
set -eo pipefail
ARTIFACT_BUCKET=$(cat bucket-name.txt)
aws cloudformation package --template-file template.yml --s3-bucket $ARTIFACT_BUCKET --
output-template-file out.yml
aws cloudformation deploy --template-file out.yml --stack-name blank-nodejs --capabilities
CAPABILITY_NAMED_IAM
La primera vez que ejecuta este script, crea una pila de AWS CloudFormation denominada blank-
nodejs. Si realiza cambios en el código de función o en la plantilla, puede ejecutarlo de nuevo para
actualizar la pila.
320
Instrumentación con el AWS X-Ray
El script de limpieza (blank-nodejs/5-cleanup.sh) elimina la pila y, opcionalmente, elimina el bucket de

implementación y los registros de funciones.
Instrumentación con el AWS X-Ray

La función de ejemplo está configurada para el seguimiento con AWS X-Ray. Con el modo de seguimiento
establecido en activo, Lambda registra la información de tiempo de un subconjunto de invocaciones y la
envía a X-Ray. X-Ray procesa los datos para generar un mapa de servicio que muestra un nodo de cliente
y dos nodos de servicio:
El primer nodo de servicio (AWS::Lambda) representa el servicio de Lambda, que valida la solicitud de
invocación y la envía a la función. El segundo nodo, AWS::Lambda::Function, representa la función en
sí.
Para registrar detalles adicionales, la función de ejemplo utiliza el SDK de X-Ray. Con cambios mínimos en
el código de función, el SDK de X-Ray registra detalles sobre las llamadas realizadas con el SDK de AWS
a los servicios de AWS.
Example blank-nodejs/function/index.js: instrumentación
const AWSXRay = require('aws-xray-sdk-core')

const AWS = AWSXRay.captureAWS(require('aws-sdk'))
// Create client outside of handler to reuse

const lambda = new AWS.Lambda()
La instrumentación del cliente de SDK de AWS agrega un nodo adicional al mapa de servicio y más
detalles en los registros de seguimiento. En este ejemplo, el mapa de servicio muestra la función de
ejemplo que llama a la API de Lambda para obtener detalles sobre el almacenamiento y el uso de
simultaneidad en la región actual.
321
Administración de dependencias con capas
El registro de seguimiento muestra detalles de tiempo para la invocación, con subsegmentos para
la inicialización de funciones, la invocación y la sobrecarga. El subsegmento de invocación tiene un
subsegmento para la llamada del SDK de AWS a la operación de la API GetAccountSettings.
Puede incluir el SDK de X-Ray y otras bibliotecas en el paquete de implementación de su función o

implementarlas por separado en una capa de Lambda. Para Node.js, Ruby y Python, el tiempo de
ejecución de Lambda incluye el SDK de AWS en el entorno de ejecución.
Administración de dependencias con capas

Puede instalar bibliotecas localmente e incluirlas en el paquete de implementación en el que cargue
Lambda, pero esto tiene sus inconvenientes. Los tamaños de archivo mayores provocan un aumento
de los tiempos de implementación y pueden impedir que pruebe los cambios en el código de función
en la consola de Lambda. Para mantener el paquete de implementación pequeño y evitar la carga de
dependencias que no han cambiado, la aplicación de ejemplo crea una capa de Lambda (p. 76) y la asocia
con la función.
Example blank-nodejs/template.yml: capa de dependencia
Resources:
function:
Properties:
Runtime: nodejs12.x
CodeUri: function/.
Timeout: 10
Policies:
Tracing: Active
Layers:
- !Ref libs
libs:
Properties:
ContentUri: lib/.
CompatibleRuntimes:
322
Procesador de errores
- nodejs12.x
El script 2-build-layer.sh instala las dependencias de la función con npm y las coloca en una carpeta
con la estructura requerida por el tiempo de ejecución de Lambda (p. 79).
Example 2-build-layer.sh: preparación de la capa
#!/bin/bash
set -eo pipefail
mkdir -p lib/nodejs
rm -rf node_modules lib/nodejs/node_modules
npm install --production
mv node_modules lib/nodejs/
La primera vez que implemente la aplicación de ejemplo, la AWS CLI empaqueta por separado la capa del
código de función e implementa ambos. En las siguientes implementaciones, el archivo de capas solo se
carga si ha cambiado el contenido de la carpeta lib.
Aplicación de ejemplo de procesamiento de errores

para AWS Lambda
La aplicación de ejemplo de procesamiento de errores demuestra el uso de AWS Lambda para controlar
los eventos procedentes de una suscripción de Amazon CloudWatch Logs (p. 202). CloudWatch Logs
le permite invocar una función de Lambda cuando una entrada de registro coincide con un patrón. La
suscripción de esta aplicación monitoriza las entradas del grupo de registros de una función que contienen
la palabra ERROR. Como respuesta, invoca una función de Lambda de procesamiento. La función de
procesamiento recupera el flujo de registros y los datos de rastreo completos de la solicitud que ha
provocado el error y los almacena para su uso posterior.
El código de la función está disponible en los siguientes archivos:
• Generador de errores aleatorios: random-error/index.js

• Procesador: processor/index.js
323
Arquitectura y estructura de eventos
Puede implementar el ejemplo en unos minutos con la AWS CLI y con AWS CloudFormation. Para
descargarlo, configurarlo e implementarlo en su cuenta, siga las instrucciones del archivo README.
Secciones
• Arquitectura y estructura de eventos (p. 324)
• Instrumentación con AWS X-Ray (p. 325)
• Plantilla de AWS CloudFormation y recursos adicionales (p. 326)

La aplicación de ejemplo utiliza los siguientes servicios de AWS.
• AWS Lambda: ejecuta el código de la función, envía los registros de CloudWatch Logs y envía los datos
de rastreo a X-Ray.
• Amazon CloudWatch Logs: recopila los registros e invoca una función cuando una entrada de registro
coincide con un patrón de filtro.
• AWS X-Ray: recopila datos de rastreo, indexa los rastros para las búsquedas y genera un mapa de
servicio.
• Amazon Simple Storage Service (Amazon S3): almacena los artefactos de implementación y la salida de
la aplicación.
Una función de Lambda en la aplicación genera errores de forma aleatoria. Cuando CloudWatch Logs
detecta la palabra ERROR en los registros de la función, envía un evento a la función de procesamiento
para su procesamiento.
Example evento de mensaje de CloudWatch Logs
{
"awslogs": {
"data": "H4sIAAAAAAAAAHWQT0/DMAzFv0vEkbLYcdJkt4qVXmCDteIAm1DbZKjS
+kdpB0Jo350MhsQFyVLsZ+unl/fJWjeO5asrPgbH5..."
}
}
Una vez descodificados, los datos contienen información sobre el evento del registro. La función utiliza
estos detalles para identificar el flujo de registros y analiza el mensaje del registro para obtener el ID de la
solicitud que ha provocado el error.
Example datos de eventos de CloudWatch Logs descodificados
{
"messageType": "DATA_MESSAGE",
"owner": "123456789012",
"logGroup": "/aws/lambda/lambda-error-processor-randomerror-1GD4SSDNACNP4",
"logStream": "2019/04/04/[$LATEST]63311769a9d742f19cedf8d2e38995b9",
"subscriptionFilters": [
"lambda-error-processor-subscription-15OPDVQ59CG07"
],
"logEvents": [
{
"id": "34664632210239891980253245280462376874059932423703429141",
"timestamp": 1554415868243,
324
Instrumentación con AWS X-Ray
"message": "2019-04-04T22:11:08.243Z\t1d2c1444-efd1-43ec-
b16e-8fb2d37508b8\tERROR\n"
}
]
}
La función de procesamiento utiliza la información del evento de CloudWatch Logs para descargar el flujo
de registros y el rastro de X-Ray completos para una solicitud que ha provocado un error. Almacena ambos
en un bucket de Amazon S3. Para permitir que finalicen el flujo de registros y tiempo de rastreo, la función
espera un breve periodo de tiempo antes de acceder a los datos.

La aplicación utiliza AWS X-Ray (p. 311) para rastrear las invocaciones de la función y las llamadas
que realizan las funciones a los servicios de AWS. X-Ray utiliza los datos de rastreo que recibe de las
funciones para crear un mapa de servicio que ayuda a identificar errores. El siguiente mapa de servicio
muestra la función de generación de errores aleatorios para algunas solicitudes. También muestra la
función de procesamiento que llama a X-Ray, CloudWatch Logs y Amazon S3.
Las dos funciones de Node.js están configuradas para el rastreo activo en la plantilla y se instrumentan
con el SDK de AWS X-Ray para Node.js en el código. Con el rastreo activo, las etiquetas Lambda añaden
un encabezado de rastreo a las solicitudes entrantes y envían un rastro con los datos de tiempo a X-Ray.
Además, la función de generación de errores aleatorios utiliza el SDK de X-Ray para registrar el ID de la
solicitud y la información del usuario en las anotaciones. Las anotaciones se asocian al rastro y se pueden
utilizar para localizar el rastro de una solicitud específica.
La función de procesamiento obtiene el ID de la solicitud del evento de CloudWatch Logs y utiliza el

AWS SDK for JavaScript para buscar dicha solicitud en X-Ray. Utiliza los clientes del SDK de AWS,
325
Plantilla de AWS CloudFormation y recursos adicionales
instrumentados con el SDK de X-Ray, para descargar el rastro y el flujo de registros. A continuación,
los almacena en el bucket de salida. El SDK de X-Ray registra estas llamadas, que aparecen como
subsegmentos en el rastro.
Plantilla de AWS CloudFormation y recursos

adicionales
La aplicación se implementa en dos módulos Node.js y se implementa con una plantilla de AWS
CloudFormation y scripts de shell. La plantilla crea la función de procesamiento, la función de generación
de errores aleatorios y los siguientes recursos complementarios.
• Rol de ejecución: rol de IAM que concede a las funciones permiso para tener acceso a otros servicios de
AWS.
• Función iniciadora: función adicional que invoca la función de generación de errores aleatorios para
crear un grupo de registros.
• Recurso personalizado: recurso personalizado de AWS CloudFormation que invoca la función iniciadora
durante la implementación para asegurarse de que el grupo de registros existe.
• Suscripción a CloudWatch Logs: suscripción al flujo de registros que activa la función de procesamiento
cuando se registra la palabra ERROR.
• Política basada en recursos: instrucción de permisos para la función de procesamiento que permite a
CloudWatch Logs invocarla.
• Bucket de Amazon S3: ubicación de almacenamiento para la salida de la función de procesamiento.
Consulte la plantilla de aplicación en GitHub.
Para solucionar una limitación de la integración de Lambda con AWS CloudFormation, la plantilla crea una
función adicional que se ejecuta durante las implementaciones. Todas las funciones de Lambda vienen
con un grupo de registros de CloudWatch Logs que almacena la salida de sus ejecuciones. Sin embargo,
el grupo de registros no se crea hasta que la función se invoca por primera vez.
Para crear la suscripción, que depende de la existencia del grupo de registros, la aplicación utiliza una
tercera función de Lambda para invocar la función de generación de errores aleatorios. La plantilla incluye
el código de la función iniciadora insertado. Un recurso de AWS CloudFormation personalizado la llama
durante la implementación. Las propiedades DependsOn permiten asegurarse de que el flujo de registros y
la política basada en recursos se han creado antes de la suscripción.
326
List manager
Aplicación de ejemplo de List manager para AWS

Lambda
La aplicación de ejemplo de list manager muestra el uso de AWS Lambda para procesar registros en
una secuencia de datos de Amazon Kinesis. Un mapeo de origen de eventos de Lambda lee registros de
la secuencia en lotes e invoca una función Lambda. La función utiliza información de los registros para
actualizar documentos en Amazon DynamoDB y almacena los registros que procesa en Amazon Relational
Database Service (Amazon RDS).
Los clientes envían registros a una secuencia de Kinesis, que los almacena y los pone a disposición para
su procesamiento. La secuencia de Kinesis se utiliza como una cola para almacenar en búfer registros
hasta que se puedan procesar. A diferencia de una cola de Amazon SQS, los registros de una secuencia
de Kinesis no se eliminan después de procesarlos, por lo que varios consumidores pueden procesar los
mismos datos. Los registros de Kinesis también se procesan en orden, mientras que los elementos de cola
se pueden entregar fuera de orden. Los registros se eliminan de la secuencia después de 7 días.
Además de la función que procesa eventos, la aplicación incluye una segunda función para realizar tareas
administrativas en la base de datos. El código de la función está disponible en los siguientes archivos:
• Procesador: processor/index.js
• Administrador de base de datos: dbadmin/index.js
Puede implementar el ejemplo en unos minutos con la AWS CLI y con AWS CloudFormation. Para
descargarlo, configurarlo e implementarlo en su cuenta, siga las instrucciones del archivo README.
Secciones
• Arquitectura y estructura de eventos (p. 328)
• Instrumentación con AWS X-Ray (p. 329)
• Plantillas de AWS CloudFormation y recursos adicionales (p. 331)
327

La aplicación de ejemplo utiliza los siguientes servicios de AWS:
• Kinesis: recibe eventos de clientes y los almacena temporalmente para su procesamiento.

• AWS Lambda: lee desde la secuencia de Kinesis y envía eventos al código del controlador de la función.
• DynamoDB: almacena listas generadas por la aplicación.
• Amazon RDS: almacena una copia de registros procesados en una base de datos relacional.
• AWS Secrets Manager: almacena la contraseña de la base de datos.
• Amazon VPC: proporciona una red privada local para la comunicación entre la función y la base de
datos.
Precios
La aplicación procesa documentos JSON de clientes que contienen la información necesaria para
actualizar una lista. Es compatible con dos tipos de listas: recuento y clasificación. Un recuento contiene
valores que se agregan al valor actual para una clave si existe. Cada entrada procesada para un usuario
aumenta el valor de una clave en la tabla especificada.
En el ejemplo siguiente se muestra un documento que aumenta el valor xp (puntos de experiencia) de la

lista stats de un usuario.
Example registro: Tipo recuento
{
"title": "stats",
"user": "bill",
"type": "tally",
"entries": {
"xp": 83
}
}
Una clasificación contiene una lista de entradas donde el valor es el orden en el que se clasifican. Una
clasificación se puede actualizar con diferentes valores que sobrescriben el valor actual, en lugar de
incrementarlo. En el siguiente ejemplo se muestra una clasificación de películas favoritas:
Example registro: Tipo de clasificación
{
"title": "favorite movies",
"user": "mike",
"type": "rank",
"entries": {
"blade runner": 1,
"the empire strikes back": 2,
"alien": 3
}
}
Un mapeo de origen de eventos (p. 109) de Lambda lee registros de la secuencia en lotes e invoca la
función de procesador. El evento que recibió el controlador de funciones contiene una matriz de objetos
328
que contienen detalles sobre un registro, como cuándo se recibió, detalles sobre la secuencia y una
representación codificada del documento de registro original.
Example events/kinesis.json: Registro
{
"Records": [
{
"kinesis": {
"sequenceNumber": "49598630142999655949899443842509554952738656579378741250",
"data":
"eyJ0aXRsZSI6ICJmYXZvcml0ZSBtb3ZpZXMiLCAidXNlciI6ICJyZGx5c2N0IiwgInR5cGUiOiAicmFuayIsICJlbnRyaWVzIjoge
},
"eventID":
"shardId-000000000000:49598630142999655949899443842509554952738656579378741250",
"invokeIdentityArn": "arn:aws:iam::123456789012:role/list-manager-
processorRole-7FYXMPLH7IUS",
"eventSourceARN": "arn:aws:kinesis:us-east-2:123456789012:stream/list-manager-
stream-87B3XMPLF1AZ"
},
...
Cuando se descodifican, los datos contienen un registro. La función utiliza el registro para actualizar la
lista del usuario y una lista de agregación que almacena los valores acumulados en todos los usuarios.
También almacena una copia del evento en la base de datos de la aplicación.

La aplicación utiliza AWS X-Ray (p. 311) para rastrear las invocaciones de la función y las llamadas
que realizan las funciones a los servicios de AWS. X-Ray utiliza los datos de rastreo que recibe de las
funciones para crear un mapa de servicio que ayuda a identificar errores. El siguiente mapa de servicios
muestra la función que se comunica con dos tablas de DynamoDB y una base de datos MySQL.
La función de Node.js está configurada para realizar un seguimiento activo de la plantilla y se instrumenta
con SDK de AWS X-Ray para Node.js en el código. El SDK de X-Ray registra un subsegmento para cada
llamada realizada con un cliente de AWS SDK o MySQL.
329
La función utiliza AWS SDK for JavaScript in Node.js para leer y escribir en dos tablas para cada registro.
La tabla principal almacena el estado actual de cada combinación de nombre de lista y usuario. La tabla
agregada almacena listas que combinan datos de varios usuarios.
330
Plantillas de AWS CloudFormation y recursos adicionales
Plantillas de AWS CloudFormation y recursos

adicionales
La aplicación se implementa en módulos de Node.js y se implementa con una plantilla de AWS
CloudFormation y scripts de shell. La plantilla de aplicación crea dos funciones, una secuencia de Kinesis,
tablas de DynamoDB y los siguientes recursos de apoyo.
Recursos de aplicaciones
• Rol de ejecución: rol de IAM que concede a las funciones permiso para tener acceso a otros servicios de
AWS.
• Mapeo de origen de eventos de Lambda: lee registros de la secuencia de datos e invoca la función.
Consulte la plantilla de aplicación en GitHub.
Una segunda plantilla, template-vpcrds.yml, crea los recursos de la base de datos y Amazon VPC. Aunque
es posible crear todos los recursos en una plantilla, separarlos facilita la limpieza de la aplicación y permite
que la base de datos se reutilice con varias aplicaciones.
Recursos de infraestructura
• VPC: una red de nube virtual privada con subredes privadas, una tabla de enrutamiento y un punto de
enlace de la VPC que permite que la función se comunique con DynamoDB sin una conexión a Internet.
• Base de datos: una instancia de base de datos de Amazon RDS y un grupo de subredes que la conecta
a la VPC.
331
Creación de funciones de Lambda

con Node.js
Puede ejecutar Código JavaScript con Node.js en AWS Lambda. Lambda proporciona tiempos de
ejecución (p. 130) para Node.js que ejecutan código para procesar eventos. El código se ejecuta en un
entorno que incluye el AWS SDK for JavaScript, con credenciales de un rol de AWS Identity and Access
Management (IAM) administrado por usted.
Lambda admite los siguientes entornos de ejecución de Node.js.
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
Las funciones de Lambda utilizan un rol de ejecución (p. 33) para obtener permiso para escribir registros
en Amazon CloudWatch Logs y para tener acceso a otros servicios y recursos. Si aún no tiene un rol de
ejecución para el desarrollo de funciones, cree uno.



Puede agregar permisos al rol más tarde o cambiarlo por otro rol específico para una sola función.
Para crear una función de Node.js
1. Abra la consola de Lambda.

3. Configure los siguientes ajustes:
• Name (Nombre): my-function.

• Runtime (Tiempo de ejecución): Node.js 12.x.
• Role (Rol): Choose an existing role (Elija un rol existente).
332
• Existing role (Rol existente): lambda-role.

5. Para configurar un evento de prueba, seleccione Test (Prueba).
6. Para Event name (Nombre de evento), escriba test.
8. Para ejecutar la función, seleccione Test (Prueba).
La consola crea una función de Lambda con un único archivo de origen denominado index.js. Puede
editar este archivo y agregar más archivos en el editor de código (p. 7) integrado. Para guardar los
cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note
La consola de Lambda utiliza AWS Cloud9 para proporcionar un entorno de desarrollo integrado
en el navegador. También puede utilizar AWS Cloud9 para desarrollar funciones Lambda en su
propio entorno. Para más información, consulte Trabajar con funciones de AWS Lambda en la
Guía del usuario de AWS Cloud9.
El archivo index.js exporta una función denominada handler que toma un objeto de evento y un objeto
context. Esta es la función de controlador (p. 334) a la que llama Lambda cuando se invoca la función. El
tiempo de ejecución de la función de Node.js obtiene los eventos de invocación de Lambda y se los pasa
al controlador. En la configuración de función, el valor de controlador es index.handler.
Cada vez que guarde el código de la función, la consola de Lambda crea un paquete de implementación,
que es un archivo ZIP que contiene el código de su función. A medida que avanza su función de desarrollo,
querrá almacenar su código de función en el control del código fuente, agregar bibliotecas y automatizar
las implementaciones. Comience creando un paquete de implementación (p. 336) y actualizando el
código en la línea de comandos.
Note
Para comenzar con el desarrollo de aplicaciones en su entorno local, implemente una de las
aplicaciones de ejemplo disponibles en el repositorio de GitHub de esta guía.
Aplicaciones de Lambda de ejemplo en Node.js
• blank-nodejs: una función de Node.js que muestra el uso de registro, las variables de entorno,
el seguimiento de AWS X-Ray, las capas, las pruebas de unidad y el SDK de AWS.
• nodejs-apig: una función con un punto de enlace de API público que procesa un evento desde
API Gateway y devuelve una respuesta HTTP.
• rds-mysql: una función que transmite consultas a una base de datos MySQL para RDS. Este
ejemplo incluye una VPC privada y una instancia de base de datos configurada con una
contraseña en AWS Secrets Manager.
• 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.
• list-manager: una función procesa eventos de un flujo de datos de Amazon Kinesis y actualiza
listas agregadas en Amazon DynamoDB. La función almacena un registro de cada evento en
una base de datos MySQL for RDS en una VPC privada. Este ejemplo incluye una VPC privada
con un punto de enlace de la VPC para DynamoDB y una instancia de base de datos.
• error-processor: una función Node.js genera errores para un porcentaje especificado de
solicitudes. Una suscripción de CloudWatch Logs invoca una segunda función cuando se
registra un error. La función de procesador utiliza el SDK de AWS para recopilar detalles sobre
la solicitud y almacenarlos en un bucket de Amazon S3.
333
Controlador
El tiempo de ejecución de la función pasa un objeto context al controlador, además del evento de
invocación. El objeto context (p. 338) contiene información adicional acerca de la invocación, la función y
el entorno de ejecución. Más información disponible en las variables de entorno.
La función de Lambda incluye un grupo de registros de CloudWatch Logs. El tiempo de ejecución de la

función envía detalles sobre cada invocación a CloudWatch Logs. Retransmite cualquier registro que
genere la función (p. 339) durante la invocación. Si la función devuelve un error (p. 342), Lambda
formatea el error y se lo devuelve al invocador.
Temas
• Controlador de la función AWS Lambda en Node.js (p. 334)
• Objeto context de AWS Lambda en Node.js (p. 338)
• Registro de funciones AWS Lambda en Node.js (p. 339)
• Instrumentación del código Node.js en AWS Lambda (p. 344)
Controlador de la función AWS Lambda en Node.js

El controlador es el método de su función de Lambda que procesa eventos. Al invocar una función, el
tiempo de ejecución (p. 130) ejecuta el método del controlador. Si el controlador existe o devuelve una
respuesta, pasará a estar disponible para gestionar otro evento.
La siguiente función de ejemplo registra el contenido del objeto de evento y devuelve la ubicación de los
registros.
Example index.js

console.log("EVENT: \n" + JSON.stringify(event, null, 2))
}
Al configurar una función (p. 54), el valor del controlador es el nombre del archivo y el nombre de un
módulo del controlador exportado, separados por un punto. El valor predeterminado en la consola y para
ejemplos de esta guía es index.handler. Esto indica el módulo handler que index.js exporta.
El tiempo de ejecución pasa tres argumentos al método del controlador. El primer argumento es el objeto
event, que contiene información del invoker. El invocador pasa esta información como una cadena con
formato JSON cuando llama a Invoke (p. 587) y el tiempo de ejecución la convierte en un objeto. Cuando
un servicio de AWS invoca su función, la estructura de eventos varía por servicio (p. 163).
El segundo argumento es el objeto context (p. 338), que incluye información sobre la invocación,
la función y el entorno de ejecución. En el ejemplo anterior, la función obtiene el nombre de flujo de
registro (p. 339) del objeto context y lo devuelve al invocador.
El tercer argumento, callback, es una función a la que puede llamar en los controladores no
asincrónicos (p. 335) para enviar una respuesta. La función de devolución de llamada toma dos
argumentos: un Error y una respuesta. Cuando lo llama, Lambda espera a que el bucle de evento esté
vacío y luego devuelve la respuesta o error al invocador. El objeto de respuesta debe ser compatible con
JSON.stringify.
En los controladores asincrónicos, debe devolver una respuesta, un error o una promesa al tiempo de
ejecución en lugar de usar callback.
334
Controladores asincrónicos
Controladores asincrónicos
En las funciones asincrónicas, puede utilizar return y throw para enviar una respuesta o un error,
respectivamente. Las funciones deben usar la palabra clave async para utilizar estos métodos a fin de
devolver una respuesta o error.
Si su código realiza una tarea asíncrona, devuelva una promesa para asegurarse que termina de
ejecutarse. Al resolver o rechazar la promesa, Lambda envía la respuesta o error al invocador.
Example Archivo index.js: solicitud HTTP con un controlador asincrónico y promesas
const https = require('https')

let url = "https://docs.aws.amazon.com/lambda/latest/dg/welcome.html"
exports.handler = async function(event) {

const promise = new Promise(function(resolve, reject) {
https.get(url, (res) => {
resolve(res.statusCode)
}).on('error', (e) => {
reject(Error(e))
})
})
return promise
}
Para las bibliotecas que devuelven una promesa, puede devolver esa promesa directamente al tiempo de
ejecución.
Example Archivo index.js: SDK de AWS con un controlador asincrónico y promesas
const AWS = require('aws-sdk')

const s3 = new AWS.S3()
exports.handler = async function(event) {

return s3.listBuckets().promise()
}
Controladores no asincrónicos
La siguiente función de ejemplo comprueba una URL y devuelve el código de estado al invocador.
Example Archivo index.js: solicitud HTTP con devolución de llamada
const https = require('https')

let url = "https://docs.aws.amazon.com/lambda/latest/dg/welcome.html"

https.get(url, (res) => {
callback(null, res.statusCode)
}).on('error', (e) => {
callback(Error(e))
})
}
En los controladores no asincrónicos, la ejecución de la función prosigue hasta que el bucle de eventos
está vacío o se agota el tiempo de espera de la función. La respuesta no se envía al invoker hasta que
todas las tareas de bucle de eventos hayan terminado. Si el tiempo de espera de la función se agota,
335
se devolverá un error en su lugar. Puede configurar el tiempo de ejecución para enviar la respuesta
inmediatamente estableciendo context.callbackWaitsForEmptyEventLoop (p. 338) en false.
En el siguiente ejemplo, la respuesta de Amazon S3 se devolverá al invocador tan pronto como esté
disponible. El tiempo de espera que se ejecuta en el bucle de eventos se ha detenido y continuará
ejecutándose la próxima vez que se invoque la función.
Example Archivo index.js: callbackWaitsForEmptyEventLoop
const AWS = require('aws-sdk')

const s3 = new AWS.S3()

context.callbackWaitsForEmptyEventLoop = false
s3.listBuckets(null, callback)
setTimeout(function () {
console.log('Timeout complete.')
}, 5000)
}
Paquete de implementación de AWS Lambda en

Node.js
Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función.
Debe crear un paquete de implementación si utiliza la API de Lambda para administrar funciones o si
necesita incluir bibliotecas y dependencias distintas del AWS SDK. Puede cargar el paquete directamente
en Lambda o utilizar un bucket de Amazon S3 y, a continuación, cargarlo en Lambda. Si el paquete de
implementación tiene más de 50 MB, debe usar Amazon S3.
Si utiliza el editor de consola (p. 7) de Lambda para crear la función, la consola administra el paquete de
implementación. Puede utilizar este método siempre y cuando no tenga que añadir ninguna biblioteca.
También puede utilizarlo para actualizar una función que ya tenga bibliotecas en el paquete de
implementación, siempre y cuando el tamaño total no supere el 3 MB.
Note
Para que el tamaño del paquete de implementación sea reducido, empaquete las dependencias
de la función en capas. Las capas le permiten administrar las dependencias de forma
independiente, pueden utilizarlas varias funciones y pueden compartirse con otras cuentas. Para
obtener más información, consulte Capas de AWS Lambda (p. 76).
Secciones
• Actualización de una función sin dependencias (p. 336)
• Actualización de una función con dependencias adicionales (p. 337)
Actualización de una función sin dependencias

Para actualizar una función mediante la API de Lambda, utilice la operación
UpdateFunctionCode (p. 659). Cree un archivo que contenga el código de la función y cárguelo con la
AWS CLI.
Para actualizar una función de Node.js sin dependencias
1. Cree un archivo ZIP.
336
Actualización de una función con dependencias adicionales
~/my-function$ zip function.zip index.js
2. Utilice el comando update-function-code para cargar el paquete.
~/my-function$ aws lambda update-function-code --function-name my-function --zip-file

fileb://function.zip
{
"FunctionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"CodeSha256": "Qf0hMc1I2di6YFMi9aXm3JtGTmcDbjniEuiYonYptAk=",
"TracingConfig": {
"Mode": "Active"
},
"RevisionId": "983ed1e3-ca8e-434b-8dc1-7d72ebadd83d",
...
}
Actualización de una función con dependencias

adicionales
Si la función depende de bibliotecas distintas del SDK for JavaScript, instálelas en un directorio local
con NPM e inclúyalas en el paquete de implementación. También puede incluir el SDK for JavaScript
si necesita una versión más reciente que la incluida en el tiempo de ejecución (p. 332), o bien para
garantizar que la versión no cambie en el futuro.
Para actualizar una función de Node.js con dependencias
1. Instale bibliotecas en el directorio node_modules con el comando npm install.
~/my-function$ npm install aws-xray-sdk
De este modo se crea una estructura de carpetas similar a la siguiente.
~/my-function
### index.js
### node_modules
### async
### async-listener
### atomic-batcher
### aws-sdk
### aws-xray-sdk
### aws-xray-sdk-core
2. Cree un archivo ZIP con el contenido de la carpeta del proyecto.
~/my-function$ zip -r function.zip .

{
337
Contexto
"TracingConfig": {
"Mode": "Active"
},
...
}
Además del código y las bibliotecas, su paquete de implementación también puede incluir archivos
ejecutables y otros recursos. Para obtener más información, consulte los siguientes temas:
• Ejecución de ejecutables en AWS Lambda

• Uso de paquetes y módulos nodejs en AWS Lambda
Objeto context de AWS Lambda en Node.js

Cuando Lambda ejecuta su función, pasa un objeto context al controlador (p. 334). Este objeto
proporciona métodos y propiedades que facilitan información acerca de la invocación, la función y el
Métodos de context
• getRemainingTimeInMillis(): Devuelve el número de milisegundos que faltan antes de que se

agote el tiempo de espera.
Propiedades de context
• functionName: El nombre de la función de Lambda.

• functionVersion: La versión (p. 70) de la función.
• invokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
Indica si el invocador ha especificado un alias o un número de versión.
• memoryLimitInMB: La cantidad de memoria que se asigna para la función.
• awsRequestId: El identificador de la solicitud de invocación.
• logGroupName: El grupo de registros de la función.
• logStreamName: El flujo de registro para la instancia de la función.
• identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
autorizado la solicitud.
• cognitoIdentityId: La identidad de Amazon Cognito autenticada.
• cognitoIdentityPoolId: El grupo de identidades de Amazon Cognito que ha autorizado la
invocación.
• clientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
aplicación del cliente.
• client.installation_id
• client.app_title
• client.app_version_name
338
Registro
• client.app_version_code
• client.app_package_name
• env.platform_version
• env.platform
• env.make
• env.model
• env.locale
• Custom: valores personalizados que establece la aplicación móvil.
• callbackWaitsForEmptyEventLoop: configúrelo en false para enviar la respuesta de forma
inmediata cuando se ejecuta la devolución de llamada (p. 335), en lugar de esperar a que el bucle de
eventos de Node.js esté vacío. Si esto es false, los eventos pendientes siguen ejecutándose durante el
siguiente periodo de invocación.
La siguiente función de ejemplo registra información de contexto y devuelve la ubicación de los registros.
Example Archivo index.js

console.log('Remaining time: ', context.getRemainingTimeInMillis())
console.log('Function name: ', context.functionName)
}
Registro de funciones AWS Lambda en Node.js

Su función de Lambda viene con un grupo de registros de CloudWatch Logs y con un flujo de registro
para cada instancia de su función. El tiempo de ejecución envía detalles sobre cada invocación al flujo de
registro y retransmite los registros y otras salidas desde el código de la función.
Para generar registros desde el código de las funciones, puede utilizar los métodos del objeto de la
consola o cualquier biblioteca de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se
registran los valores de las variables de entorno y el objeto de evento.
Example Archivo index.js: registro

console.log("ENVIRONMENT VARIABLES\n" + JSON.stringify(process.env, null, 2))
console.info("EVENT\n" + JSON.stringify(event, null, 2))
console.warn("Event not processed.")
}
Example formato de registro
START RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Version: $LATEST

2019-06-07T19:11:20.562Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO ENVIRONMENT VARIABLES
{
"AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
"AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
"AWS_LAMBDA_LOG_STREAM_NAME": "2019/06/07/[$LATEST]e6f4a0c4241adcd70c262d34c0bbc85c",
"AWS_EXECUTION_ENV": "AWS_Lambda_nodejs12.x",
"AWS_LAMBDA_FUNCTION_NAME": "my-function",
"PATH": "/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin",
339
Visualización de registros en la
Consola de administración de AWS
"NODE_PATH": "/opt/nodejs/node10/node_modules:/opt/nodejs/node_modules:/var/runtime/
node_modules",
...
}
2019-06-07T19:11:20.563Z c793869b-ee49-115b-a5b6-4fd21e8dedac INFO EVENT
{
"key": "value"
}
2019-06-07T19:11:20.564Z c793869b-ee49-115b-a5b6-4fd21e8dedac WARN Event not processed.
END RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac
REPORT RequestId: c793869b-ee49-115b-a5b6-4fd21e8dedac Duration: 128.83 ms Billed Duration:
200 ms Memory Size: 128 MB Max Memory Used: 74 MB Init Duration: 166.62 ms XRAY TraceId:
1-5d9d007f-0a8c7fd02xmpl480aed55ef0 SegmentId: 3d752xmpl1bbe37e Sampled: true
El tiempo de ejecución de Node.js registra las líneas START, END y REPORT de cada invocación. Se agrega
una marca de tiempo, un ID de solicitud y el nivel de registro en cada entrada registrada por la función. La
línea del informe proporciona los siguientes detalles.
Registro de informes
• RequestId: el identificador de solicitud único para la invocación.

• Duration: la cantidad de tiempo que el método de controlador de la función dedicó al procesamiento del
evento.
• Billed Duration: la cantidad de tiempo facturado para la invocación.
• Memory Size: la cantidad de memoria asignada a la función.
• Max Memory Used: la cantidad de memoria utilizada por la función.
• Init Duration: para la primera solicitud servida, la cantidad de tiempo que tardó el tiempo de ejecución en
cargar la función y ejecutar código fuera del método del controlador.
• XRAY TraceId: para las solicitudes rastreadas el ID de rastreo de AWS X-Ray (p. 311).
• SegmentId: para las solicitudes rastreadas, el ID del segmento de X-Ray.
• Sampled: para solicitudes rastreadas, el resultado del muestreo.
Puede ver los registros en la consola de Lambda o en la de CloudWatch Logs, o bien en la línea de
comandos.
Secciones
• Visualización de registros en la Consola de administración de AWS (p. 340)
• Mediante AWS CLI (p. 341)
• Eliminación de registros (p. 342)
Visualización de registros en la Consola de

administración de AWS
La consola de Lambda muestra el resultado del registro cuando prueba una función en la página de
configuración de la función. Para ver los registros de todas las invocaciones, utilice la consola de
CloudWatch Logs.
Para ver los registros de la función de Lambda
1. Abra la página de registros de la consola de CloudWatch.

2. Seleccione el grupo de registros para su función (/aws/lambda/nombre-función).
3. Elija el primer flujo en la lista.
340
Mediante AWS CLI
Cada flujo de registro se corresponde con una instancia de su función (p. 132). Los nuevos flujos aparecen
cuando se actualiza la función y cuando se crean más instancias para atendar varias invocaciones
simultáneas. Para buscar los registros de invocaciones específicas, puede instrumentar la función con
X-Ray y registrar los detalles sobre el flujo de registro y la solicitud en el registro de seguimiento. Para
obtener una aplicación de ejemplo que correlacione registros y rastros de seguimiento con X-Ray, consulte
Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}

#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
341
Eliminación de registros
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
}
],
}
Los grupos de registros no se eliminan automáticamente al eliminar una función. Para evitar los registros
de almacenamiento de forma indefinida, elimine el grupo de registros o configure un periodo de retención
después del cual los registros se eliminarán automáticamente.
Errores de funciones AWS Lambda en Node.js

Cuando el código devuelve un error, Lambda genera una representación JSON de este. Este documento
de error aparece en el registro de invocación y, en el caso de las invocaciones síncronas, en la salida.
Example Archivo index.js: error de referencia
exports.handler = async function() {

return x + 10
}
Este código da como resultado un error de referencia. Lambda detecta el error y genera un documento
JSON con campos para el mensaje de error, el tipo y el seguimiento de la pila.
{
"errorType": "ReferenceError",
342
Errores
"errorMessage": "x is not defined",

"trace": [
"ReferenceError: x is not defined",
" at Runtime.exports.handler (/var/task/index.js:2:3)",
" at Runtime.handleOnce (/var/runtime/Runtime.js:63:25)",
" at process._tickCallback (internal/process/next_tick.js:68:7)"
]
}
Cuando se invoca la función desde la línea de comandos, la AWS CLI divide la respuesta en dos
documentos. Para indicar que se ha producido un error en la función, la respuesta que se muestra en el
terminal incluye un campo FunctionError. La respuesta o el error que devuelve la función se escribe en
el archivo de salida.
$ aws lambda invoke --function-name my-function out.json

{
"StatusCode": 200,
"FunctionError": "Unhandled",
}
Examine el archivo de salida para ver el documento de error.
$ cat out.json
{"errorType":"ReferenceError","errorMessage":"x is not defined","trace":["ReferenceError:
x is not defined"," at Runtime.exports.handler (/var/task/index.js:2:3)"," at
Runtime.handleOnce (/var/runtime/Runtime.js:63:25)"," at process._tickCallback (internal/
process/next_tick.js:68:7)"]}
Note
El código de estado 200 (correcto) de la respuesta de Lambda indica que no hubo ningún error
en la solicitud que envió a Lambda. Para ver los problemas que generan un código de estado de
error, consulte Errors (p. 589).
Lambda también registra hasta 256 KB del objeto de error en los registros de la función. Para ver los
registros cuando realice la invocación de la función desde la línea de comandos, utilice la opción --log-
type y descodifique la cadena base64 de la respuesta.
$ aws lambda invoke --function-name my-function out.json --log-type Tail \

START RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 Version: $LATEST
2019-06-05T22:11:27.082Z 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 ERROR Invoke
Error {"errorType":"ReferenceError","errorMessage":"x is not defined","stack":
["ReferenceError: x is not defined"," at Runtime.exports.handler (/var/task/
index.js:2:3)"," at Runtime.handleOnce (/var/runtime/Runtime.js:63:25)"," at
process._tickCallback (internal/process/next_tick.js:68:7)"]}
END RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64
REPORT RequestId: 8bbbfb91-a3ff-4502-b1b7-cb8f6658de64 Duration: 76.85 ms Billed
Para obtener más información acerca de los registros, consulte Registro de funciones AWS Lambda en
Node.js (p. 339).
En función del origen de eventos, AWS Lambda podría volver a intentar la ejecución de la función de
Lambda que ha generado un error. Por ejemplo, si Kinesis es el origen de eventos, AWS Lambda reintenta
la invocación que produce errores hasta que la función de Lambda se ejecute correctamente o hasta que
los registros del flujo caduquen. Para obtener más información acerca de los reintentos, consulte Control
de errores y reintentos automáticos en AWS Lambda (p. 119).
343
Tracing
Instrumentación del código Node.js en AWS

Lambda
Lambda se integra con AWS X-Ray para permitirle rastrear, depurar y optimizar las aplicaciones de
Lambda. Puede utilizar X-Ray para rastrear una solicitud a medida que esta recorre los recursos de la
aplicación, desde el frontend de la API hasta el almacenamiento y la base de datos del backend. Solo
con agregar la biblioteca de X-Ray SDK a la configuración de compilación, puede registrar los errores y la
latencia de cualquier llamada que realice la función a un servicio de AWS.
El mapa de servicio de X-Ray muestra el flujo de solicitudes de la aplicación. En el siguiente ejemplo de la

aplicación de ejemplo de procesamiento de errores (p. 323) se muestra una aplicación con dos funciones.
La función principal procesa eventos y, a veces, devuelve errores. La segunda función procesa los errores
que aparecen en el grupo de registros de la primera y utiliza AWS SDK para llamar a X-Ray, Amazon S3 y
Amazon CloudWatch Logs.

Precios
344
Tracing
Cuando el rastreo activo está habilitado, Lambda registra el rastreo de un subconjunto de invocaciones.
Lambda registra dos segmentos, lo que crea dos nodos en el mapa de servicio. El primer nodo representa
el servicio de Lambda que recibe la solicitud de invocación. El tiempo de ejecución (p. 19) de la función
registra el segundo nodo.
Puede instrumentar su código de controlador para registrar metadatos y rastrear llamadas descendentes.
Para registrar detalles sobre las llamadas que su controlador realiza a otros recursos y servicios, use
el SDK para Node.js de X-Ray. Para obtener el SDK, agregue el paquete aws-xray-sdk-core a las
dependencias de su aplicación.
Example blank-nodejs/package.json
{
"name": "blank-nodejs",
"version": "1.0.0",
"private": true,
"devDependencies": {
"aws-sdk": "2.631.0",
"jest": "25.4.0"
},
"dependencies": {
"aws-xray-sdk-core": "1.1.2"
},
"scripts": {
"test": "jest"
}
}
Para instrumentar clientes SDK de AWS, ajuste la biblioteca de aws-sdk con el método captureAWS.
Example blank-nodejs/function/index.js: Seguimiento de un cliente SDK de AWS
const AWSXRay = require('aws-xray-sdk-core')

const AWS = AWSXRay.captureAWS(require('aws-sdk'))
// Create client outside of handler to reuse

const lambda = new AWS.Lambda()
// Handler
345
Habilitación del seguimiento activo con la API de Lambda
...
El primer segmento representa la solicitud de invocación procesada por el servicio Lambda. El segundo
segmento registra el trabajo realizado por la función. El segmento de la función tiene 3 subsegmentos.
• Initialization (Inicialización) – Representa el tiempo dedicado a cargar la función y ejecutar el código de

inicialización (p. 20). Este subsegmento únicamente aparece para el primer evento procesado por cada
instancia de la función.
• Invocation (Invocación) – Representa el trabajo realizado por el código del controlador. Al instrumentar el
código, puede extender este subsegmento mediante subsegmentos adicionales.
• Overhead (Sobrecarga) – Representa el trabajo realizado por el tiempo de ejecución de Lambda con el
fin de prepararse para controlar el siguiente evento.
También puede instrumentar clientes HTTP, registrar consultas SQL y crear subsegmentos personalizados
con anotaciones y metadatos. Para obtener más información, consulte SDK de X-Ray para Node.js en la
Guía para desarrolladores de AWS X-Ray.
Secciones
• Almacenamiento de dependencias en tiempo de ejecución en una capa (p. 347)

Lambda

function».
346

publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...

Resources:
function:
Properties:
Tracing: Active
...
Almacenamiento de dependencias en tiempo de

ejecución en una capa
Si utiliza el SDK de X-Ray para instrumentar el código de las funciones de los clientes del SDK de AWS, el
paquete de implementación puede llegar a ser bastante grande. Para evitar que se carguen dependencias
en tiempo de ejecución cada vez que se actualice el código de las funciones, empaquételas en una capa
de Lambda (p. 76).
En el ejemplo siguiente, se muestra un recurso de AWS::Serverless::LayerVersion que almacena el

SDK para Node.js de X-Ray.
Example template.yml: capa de dependencias
Resources:
function:
Properties:
CodeUri: function/.
Tracing: Active
347
Almacenamiento de dependencias
en tiempo de ejecución en una capa
Layers:
- !Ref libs
...
libs:
Properties:
ContentUri: lib/.
CompatibleRuntimes:
- nodejs12.x
Con esta configuración, solo actualiza la capa de la biblioteca si se modifican las dependencias del tiempo
de ejecución. El paquete de implementación de funciones solo contiene su código. Cuando actualiza el
código de la función, el tiempo de carga es mucho más rápido que si incluye dependencias en el paquete
de implementación.
Para crear una capa de dependencias, es necesario realizar cambios en la compilación para generar el
archivo de capas antes de la implementación. Para ver un ejemplo de trabajo, consulte la aplicación de
ejemplo blank-nodejs .
348

con Python
Puede ejecutar Python code en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 130) para
Python que ejecutan código para procesar eventos. El código se ejecuta en un entorno que incluye el
SDK para Python (Boto3), con credenciales de un rol de AWS Identity and Access Management (IAM)
administrado por usted.
Lambda admite los siguientes entornos de ejecución de Python.
Tiempos de ejecución de Python
Python 3.8 python3.8 boto3-1.12.49 Amazon Linux 2

botocore-1.15.49

botocore-1.15.49

botocore-1.15.49

botocore-1.15.49



Para crear una función de Python

349

• Runtime (Tiempo de ejecución): Python 3.8.
La consola crea una función de Lambda con un único archivo de origen denominado lambda_function.
Puede editar este archivo y agregar más archivos en el editor de código (p. 7) integrado. Para guardar los
cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note
El archivo lambda_function exporta una función denominada lambda_handler que toma un objeto
de evento y un objeto context. Esta es la función de controlador (p. 351) a la que llama Lambda cuando
se invoca la función. El tiempo de ejecución de la función de Python obtiene los eventos de invocación
de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador es
lambda_function.lambda_handler.
Note
Aplicaciones de Lambda de ejemplo en Python
• blank-python: una función de Python que muestra el uso del registro, las variables de entorno,
el seguimiento de AWS X-Ray, las capas, las pruebas unitarias y el SDK de AWS.

Temas
350
Controlador
• Controlador de funciones AWS Lambda en Python (p. 351)

• Objeto context de AWS Lambda en Python (p. 355)
• Registro de funciones de AWS Lambda en Python (p. 357)
• Instrumentación del código Python en AWS Lambda (p. 361)
Controlador de funciones AWS Lambda en Python

En el momento de crear una función de Lambda, debe especificar un controlador, que es una función en el
código, que AWS Lambda puede invocar cuando el servicio ejecuta el código. Utilice la siguiente estructura
de sintaxis general al crear una función de controlador en Python.
def handler_name(event, context):

...
return some_value
En la sintaxis, tenga en cuenta lo siguiente:
• event: AWS Lambda utiliza este parámetro para pasar datos de eventos al controlador. Este parámetro
suele ser del tipo dict de Python. También puede ser del tipo list, str, int, float, o NoneType.
Cuando se invoca una función, se determina el contenido y la estructura del evento. Cuando un servicio
de AWS invoca su función, la estructura del evento varía en función del servicio. Para obtener más
información, consulte Utilización de AWS Lambda con otros servicios (p. 163).
• context: AWS Lambda utiliza este parámetro para proporcionar información sobre el tiempo de
ejecución al controlador. Para obtener más información, consulte Objeto context de AWS Lambda en
Python (p. 355).
• Si lo desea, el controlador puede devolver un valor. Lo que sucede con el valor devuelto depende del
tipo de invocación que se utilice al invocar la función de Lambda:
• Si se utiliza el tipo de invocación RequestResponse (ejecución síncrona), AWS Lambda devuelve
el resultado de la llamada a la función de Python al cliente que invoca la función de Lambda (en la
respuesta HTTP a la solicitud de invocación, serializada en JSON). Por ejemplo, la consola de AWS
Lambda utiliza el tipo de invocación RequestResponse, por lo que al invocar la función utilizando la
consola, esta mostrará el valor devuelto.
• Si el controlador devuelve objetos que no se pueden serializar con json.dumps, el tiempo de
ejecución devuelve un error.
• Si el controlador devuelve None, al igual que hacen las funciones de Python sin una instrucción
return, el runtime devuelve null.
• Si se utiliza el tipo de invocación Event (ejecución asíncrona), el valor se descarta.
Por ejemplo, fíjese en el siguiente código de ejemplo de Python.
def my_handler(event, context):

message = 'Hello {} {}!'.format(event['first_name'],
event['last_name'])
return {
'message' : message
}
Este ejemplo tiene una función denominada my_handler. La función devuelve un mensaje que contiene
los datos del evento que recibió como entrada.
351

Python
Note
Puede utilizar el comando build de la CLI de AWS SAM para crear un paquete de
implementación para el código y las dependencias de la función de Python. La CLI de AWS SAM
también proporciona una opción para crear el paquete de implementación dentro de una imagen
de Docker que es compatible con el entorno de ejecución de Lambda. Para obtener instrucciones,
consulte el tema relacionado con la creación de aplicaciones con dependencias en la guía para
desarrolladores de AWS SAM.
Secciones
• Con un entorno virtual (p. 354)
Requisitos previos
En estas instrucciones se da por hecho que ya tiene una función. Si no ha creado aún una función,
consulte Creación de funciones de Lambda con Python (p. 349).

this is output

Para crear o actualizar una función con la API de Lambda, cree un archivo que contenga el código de la
función y cárguelo con la AWS CLI.
Para actualizar una función de Python sin dependencias
352
~/my-function$ zip function.zip lambda_function.py


{
"Runtime": "python3.8",
"Handler": "lambda_function.lambda_handler",
"CodeSize": 815,
"CodeSha256": "GcZ05oeHoJi61VpQj7vCLPs8DwCXmX5sE/fE2IHsizc=",
"RevisionId": "d1e983e3-ca8e-434b-8dc1-7add83d72ebd",
...
}

adicionales
Si la función depende de bibliotecas distintas del SDK para Python (Boto3), instálelas en un directorio local
con pip e inclúyalas en el paquete de implementación.
Note
Para las bibliotecas que utilizan módulos de extensión escritos en C o C++, cree el paquete de
implementación en un entorno de Amazon Linux. Puede utilizar el comando de compilación de la
CLI de SAM, que utiliza Docker, o crear el paquete de implementación en Amazon EC2 o AWS
CodeBuild.
En el ejemplo siguiente se muestra cómo crear un paquete de implementación que incluya una biblioteca
de gráficos común denominada Pillow.
Para actualizar una función de Python con dependencias
1. Instale las bibliotecas en un nuevo directorio package local del proyecto con la opción --target de
pip.
~/my-function$ pip install --target ./package Pillow

Collecting Pillow
Using cached https://files.pythonhosted.org/
packages/62/8c/230204b8e968f6db00c765624f51cfd1ecb6aea57b25ba00b240ee3fb0bd/
Pillow-5.3.0-cp37-cp37m-manylinux1_x86_64.whl
Installing collected packages: Pillow
Successfully installed Pillow-5.3.0
Note
Para que --target funcione en sistemas basados en Debian como Ubuntu, es posible que
también tenga que transferir la marca --system para evitar errores distutils.
2. Cree un archivo ZIP de las dependencias.
~/my-function$ cd package
353
Con un entorno virtual
~/my-function/package$ zip -r9 ${OLDPWD}/function.zip .

adding: PIL/ (stored 0%)
adding: PIL/.libs/ (stored 0%)
adding: PIL/.libs/libfreetype-7ce95de6.so.6.16.1 (deflated 65%)
adding: PIL/.libs/libjpeg-3fe7dfc0.so.9.3.0 (deflated 72%)
adding: PIL/.libs/liblcms2-a6801db4.so.2.0.8 (deflated 67%)
...
3. Añada el código de la función al archivo comprimido.
~/my-function/package$ cd $OLDPWD
~/my-function$ zip -g function.zip lambda_function.py
4. Actualice el código de la función.

{
"CodeSize": 2269409,
"CodeSha256": "GcZ05oeHoJi61VpQj7vCLPs8DwCXmX5sE/fE2IHsizc=",
"RevisionId": "a9c05ffd-8ad6-4d22-b6cd-d34a00c1702c",
...
}
Con un entorno virtual

En algunos casos, puede que tenga que utilizar un entorno virtual para instalar las dependencias de la
función. Esto puede ocurrir si la función o sus dependencias dependen de las bibliotecas nativas o si utiliza
Homebrew para instalar Python.
Para actualizar una función de Python con un entorno virtual
1. Cree un entorno virtual.
~/my-function$ virtualenv v-env

Using base prefix '~/.local/python-3.7.0'
New python executable in v-env/bin/python3.8
Also creating executable in v-env/bin/python
Installing setuptools, pip, wheel...
done.
Note
En Python 3.3 y posteriores, puede utilizar el módulo venv integrado para crear un entorno
virtual, en lugar de instalar virtualenv.
~/my-function$ python3 -m venv v-env
2. Active el entorno.
~/my-function$ source v-env/bin/activate
354
Contexto
(v-env) ~/my-function$
3. Instale las bibliotecas con pip.
(v-env) ~/my-function$ pip install Pillow

Collecting Pillow
Using cached https://files.pythonhosted.org/
packages/62/8c/230204b8e968f6db00c765624f51cfd1ecb6aea57b25ba00b240ee3fb0bd/
Pillow-5.3.0-cp37-cp37m-manylinux1_x86_64.whl
Installing collected packages: Pillow
Successfully installed Pillow-5.3.0
4. Desactive el entorno virtual.
(v-env) ~/my-function$ deactivate
5. Cree un archivo ZIP con el contenido de la biblioteca.
~/my-function$ cd v-env/lib/python3.8/site-packages
~/my-function/v-env/lib/python3.8/site-packages$ zip -r9 ${OLDPWD}/function.zip .
adding: easy_install.py (deflated 17%)
adding: PIL/ (stored 0%)
adding: PIL/.libs/ (stored 0%)
adding: PIL/.libs/libfreetype-7ce95de6.so.6.16.1 (deflated 65%)
adding: PIL/.libs/libjpeg-3fe7dfc0.so.9.3.0 (deflated 72%)
...
En función de la biblioteca, las dependencias pueden aparecer en site-packages o en dist-

packages, y la primera carpeta del entorno virtual puede ser lib o lib64. Puede utilizar el comando
pip show para localizar un paquete específico.
6. Añada el código de la función al archivo comprimido.
~/my-function/v-env/lib/python3.8/site-packages$ cd $OLDPWD
~/my-function$ zip -g function.zip lambda_function.py

{
"CodeSize": 5912988,
"CodeSha256": "A2P0NUWq1J+LtSbkuP8tm9uNYqs1TAa3M76ptmZCw5g=",
"RevisionId": "5afdc7dc-2fcb-4ca8-8f24-947939ca707f",
...
}
Objeto context de AWS Lambda en Python

355
Contexto
Métodos de context
• get_remaining_time_in_millis – Devuelve el número de milisegundos que faltan antes de que se

• function_name – El nombre de la función de Lambda.

• function_version – La versión (p. 70) de la función.
• invoked_function_arn – El nombre de recurso de Amazon (ARN) que se utiliza para invocar la
función. Indica si el invocador ha especificado un alias o un número de versión.
• memory_limit_in_mb – La cantidad de memoria que se asigna para la función.
• aws_request_id – El identificador de la solicitud de invocación.
• log_group_name – El grupo de registros de la función.
• log_stream_name: El flujo de registro para la instancia de la función.
• identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
• cognito_identity_id: La identidad de Amazon Cognito autenticada.
• cognito_identity_pool_id: El grupo de identidades de Amazon Cognito que ha autorizado la
invocación.
• client_context: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de
la aplicación del cliente.
• client.installation_id
• client.app_title
• client.app_version_name
• client.app_version_code
• client.app_package_name
• custom: un elemento dict de valores personalizados establecidos por la aplicación cliente para
móviles.
• env: un elemento dict de información de entorno proporcionado por el AWS SDK.
En el siguiente ejemplo se muestra una función de controlador que registra información de context.
Example handler.py
import time
def get_my_log_stream(event, context):
print("Log stream name:", context.log_stream_name)
print("Log group name:", context.log_group_name)
print("Request ID:",context.aws_request_id)
print("Mem. limits(MB):", context.memory_limit_in_mb)
# Code will execute quickly, so we add a 1 second intentional delay so you can see that
in time remaining value.
time.sleep(1)
print("Time remaining (MS):", context.get_remaining_time_in_millis())
Además de las opciones que se enumeran anteriormente, también puede utilizar el SDK de AWS X-Ray
para Instrumentación del código Python en AWS Lambda (p. 361) a fin de identificar las rutas de código
críticas, rastrear su desempeño y capturar los datos para su análisis.
356
Registro
Registro de funciones de AWS Lambda en Python

Para generar registros desde el código de su función, puede utilizar el método print o cualquier biblioteca
de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se registran los valores de las
variables de entorno y el objeto de evento.
Example lambda_function.py
import os

print('## ENVIRONMENT VARIABLES')
print(os.environ)
print('## EVENT')
print(event)
Example Formato de registro
START RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Version: $LATEST

## ENVIRONMENT VARIABLES
environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function',
'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]3893xmpl7fac4485b47bb75b671a283c',
'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
## EVENT
{'key': 'value'}
END RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95
REPORT RequestId: 8f507cfc-xmpl-4697-b07a-ac58fc914c95 Duration: 15.74 ms Billed
Duration: 100 ms Memory Size: 128 MB Max Memory Used: 56 MB Init Duration: 130.49 ms
XRAY TraceId: 1-5e34a614-10bdxmplf1fb44f07bc535a1 SegmentId: 07f5xmpl2d1f6f85 Sampled:
true
El tiempo de ejecución de Python registra las líneas START, END y REPORT de cada invocación. La línea
del informe proporciona los siguientes detalles.

evento.
comandos.
357
Secciones
• Biblioteca de registro (p. 360)

CloudWatch Logs.

Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}

358
Mediante AWS CLI
#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
}
],
}
359
Biblioteca de registro
Para obtener registros más detallados, utilice la biblioteca de registro.
import os
import logging

logger.info('## ENVIRONMENT VARIABLES')
logger.info(os.environ)
logger.info('## EVENT')
logger.info(event)
La salida de logger incluye el nivel de registro, la marca de tiempo y el ID de la solicitud.
START RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Version: $LATEST

[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## ENVIRONMENT
VARIABLES
[INFO] 2020-01-31T22:12:58.534Z 1c8df7d3-xmpl-46da-9778-518e6eca8125

environ({'AWS_LAMBDA_LOG_GROUP_NAME': '/aws/lambda/my-function',
'AWS_LAMBDA_LOG_STREAM_NAME': '2020/01/31/[$LATEST]1bbe51xmplb34a2788dbaa7433b0aa4d',
'AWS_LAMBDA_FUNCTION_NAME': 'my-function', ...})
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 ## EVENT
[INFO] 2020-01-31T22:12:58.535Z 1c8df7d3-xmpl-46da-9778-518e6eca8125 {'key':

'value'}
END RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125

REPORT RequestId: 1c8df7d3-xmpl-46da-9778-518e6eca8125 Duration: 2.75 ms Billed
XRAY TraceId: 1-5e34a66a-474xmpl7c2534a87870b4370 SegmentId: 073cxmpl3e442861 Sampled:
true
Errores de funciones de AWS Lambda en Python

Example Archivo lambda_function.py: excepción

return x + 10
Este código da como resultado un error de nombre. Lambda detecta el error y genera un documento JSON
con campos para el mensaje de error, el tipo y el seguimiento de la pila.
360
Tracing
{
"errorMessage": "name 'x' is not defined",
"errorType": "NameError",
"stackTrace": [
" File \"/var/task/error_function.py\", line 2, in lambda_handler\n return x +
10\n"
]
}

{
"StatusCode": 200,
}
$ cat out.json
{"errorMessage": "name 'x' is not defined", "errorType": "NameError", "stackTrace": ["
File \"/var/task/error_function.py\", line 2, in lambda_handler\n return x + 10\n"]}
Note

START RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9 Version: $LATEST
return x + 10/lambda_function.py", line 2, in lambda_handler
END RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9
REPORT RequestId: fc4f8810-88ff-4800-974c-12cec018a4b9 Duration: 12.33 ms Billed Duration:
100 ms Memory Size: 128 MB Max Memory Used: 56 MB
Para obtener más información acerca de los registros, consulte Registro de funciones de AWS Lambda en
Python (p. 357).
Instrumentación del código Python en AWS

Lambda
361
Tracing


Precios
362
Tracing
Para registrar detalles sobre las llamadas que su controlador realiza a otros recursos y servicios, use el
SDK de X-Ray para Python. Para obtener el SDK, agregue el paquete aws-xray-sdk a las dependencias
de su aplicación.
Example blank-python/function/requirements.txt
jsonpickle==1.3
aws-xray-sdk==2.4.3
Para instrumentar clientes SDK de AWS, aplique un parche a la biblioteca de boto3 con el módulo
aws_xray_sdk.core.
Example blank-python/function/lambda_function.py: Seguimiento de un cliente SDK de AWS
import boto3
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.core import patch_all
patch_all()
client = boto3.client('lambda')
client.get_account_settings()

logger.info('## ENVIRONMENT VARIABLES\r' + jsonpickle.encode(dict(**os.environ)))
...
363

con anotaciones y metadatos. Para obtener más información, vea SDK de X-Ray para Python en la Guía
para desarrolladores de AWS X-Ray.
Secciones

Lambda

function».

364
publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...

Resources:
function:
Properties:
Tracing: Active
...

de Lambda (p. 76).

SDK de X-Ray para Python.
Resources:
function:
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
365
Properties:
LayerName: blank-python-lib
Description: Dependencies for the blank-python sample app.
ContentUri: package/.
CompatibleRuntimes:
- python3.8
de implementación.
ejemplo blank-python.
366

con Ruby
Puede ejecutar Ruby code en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 130) para Ruby
que ejecutan código para procesar eventos. El código se ejecuta en un entorno que incluye el AWS SDK
parar Ruby, con credenciales de un rol de AWS Identity and Access Management (IAM) administrado por
usted.
Lambda admite los siguientes entornos de ejecución de Ruby.
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



Para crear una función de Ruby


• Runtime (Tiempo de ejecución): Ruby 2.7.
367

La consola crea una función de Lambda con un único archivo de origen denominado
lambda_function.rb. Puede editar este archivo y agregar más archivos en el editor de código (p. 7)
integrado. Para guardar los cambios, elija Save. A continuación, para ejecutar el código, elija Test (Probar).
Note
El archivo lambda_function.rb exporta una función denominada lambda_handler que toma un

objeto de evento y un objeto context. Esta es la función de controlador (p. 369) a la que llama Lambda
cuando se invoca la función. El tiempo de ejecución de la función de Ruby obtiene los eventos de
invocación de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador
es lambda_function.lambda_handler.
Note
Aplicaciones de Lambda de ejemplo en Ruby
• blank-ruby: una función de Ruby que muestra el uso del registro, las variables de entorno, el
seguimiento de AWS X-Ray, las pruebas de unidad y el SDK de AWS.

Temas
• Controlador de funciones de AWS Lambda en Ruby (p. 369)
368
Controlador
• Objeto context de AWS Lambda en Ruby (p. 371)

• Registro de funciones de AWS Lambda en Ruby (p. 372)
• Instrumentación del código Ruby en AWS Lambda (p. 378)
Controlador de funciones de AWS Lambda en Ruby

El controlador de funciones de Lambda es el método al que llama Lambda cuando se invoca la función.
En el siguiente ejemplo, el archivo function.rb define un método de controlador llamado handler. La
función de controlador tiene dos objetos como entrada y devuelve un documento JSON.
Example function.rb
require 'json'
def handler(event:, context:)

{ event: JSON.generate(event), context: JSON.generate(context.inspect) }
end
En su configuración de la función, el valor handler indica a Lambda dónde encontrar el controlador.

Para el ejemplo anterior, el valor correcto para este valor es function.handler. Incluye dos nombres
separados por un punto: el nombre del archivo y el nombre del método del controlador.
También puede definir su método de controlador en una clase. En el siguiente ejemplo se define
un método de controlador llamado process en una clase llamada Handler en un módulo llamado
LambdaFunctions.
Example source.rb
module LambdaFunctions
class Handler
def self.process(event:,context:)
"Hello!"
end
end
end
En este caso, el valor del controlador es source.LambdaFunctions::Handler.process.
Los dos objetos que el controlador acepta son el evento de invocación y el contexto. El evento es un
objeto Ruby que contiene la carga que proporciona el invocador. Si la carga es un documento JSON, el
objeto de evento es un hash de Ruby. De lo contrario, es una cadena. Este objeto de contexto (p. 371)
tiene métodos y propiedades que facilitan información acerca de la invocación, la función y el entorno de
ejecución.
El controlador de la función se ejecuta cada vez que se invoca la función de Lambda. El código estático
fuera del controlador se ejecuta una vez por instancia de la función. Si su controlador utiliza recursos como
clientes de SDK y conexiones de bases de datos, puede crearlos fuera del método de controlador para
volver a utilizarlos en varias invocaciones.
Cada instancia de la función permite procesar varios eventos de invocación, pero solo procesa un evento
cada vez. El número de instancias que procesan un evento en un momento dado es la simultaneidad de la
función. Para obtener más información acerca del contexto de ejecución de Lambda, consulte Contexto de
ejecución de AWS Lambda (p. 132).
369

Ruby
Note
Secciones

Para actualizar una función mediante la API de Lambda, utilice la operación
UpdateFunctionCode (p. 659). Cree un archivo que contenga el código de la función y cárguelo con la
AWS CLI.
Para actualizar una función de Ruby sin dependencias
~/my-function$ zip function.zip function.rb

{
"Runtime": "ruby2.5",
"TracingConfig": {
"Mode": "Active"
},
...
}
370

adicionales
Si la función depende de bibliotecas distintas a AWS SDK parar Ruby, instálelas en un directorio local con
Bundler e inclúyalas en el paquete de implementación.
Para actualizar una función de Ruby con dependencias
1. Instale las bibliotecas en el directorio del proveedor con el comando bundle.
~/my-function$ bundle install --path vendor/bundle

Fetching gem metadata from https://rubygems.org/..............
Resolving dependencies...
Fetching aws-eventstream 1.0.1
Installing aws-eventstream 1.0.1
...
--path instala las gemas en el directorio del proyecto en lugar de en la ubicación del sistema, y
establece este como la ruta predeterminada para las futuras instalaciones. Para instalar luego gemas
globalmente, utilice la opción --system.
package$ zip -r function.zip function.rb vendor

adding: function.rb (deflated 37%)
adding: vendor/ (stored 0%)
adding: vendor/bundle/ (stored 0%)
adding: vendor/bundle/ruby/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/build_info/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/cache/ (stored 0%)
adding: vendor/bundle/ruby/2.7.0/cache/aws-eventstream-1.0.1.gem (deflated 36%)
...

{
"Runtime": "ruby2.5",
"CodeSize": 300,
...
}
Objeto context de AWS Lambda en Ruby

371
Registro
Métodos de context
• get_remaining_time_in_millis – Devuelve el número de milisegundos que faltan antes de que se

• function_name – El nombre de la función de Lambda.

• function_version – La versión (p. 70) de la función.
• invoked_function_arn – El nombre de recurso de Amazon (ARN) que se utiliza para invocar la
función. Indica si el invocador ha especificado un alias o un número de versión.
• memory_limit_in_mb – La cantidad de memoria que se asigna para la función.
• aws_request_id – El identificador de la solicitud de invocación.
• log_group_name – El grupo de registros de la función.
• log_stream_name – El flujo de registro para la instancia de la función.
• deadline_ms– La fecha en la que la función agota su tiempo de espera en milisegundos de tiempo
Unix.
• identity – (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
• client_context– (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de
la aplicación del cliente.
Registro de funciones de AWS Lambda en Ruby

Para generar registros desde el código de su función puede utilizar instrucciones puts o cualquier
biblioteca de registro que escriba en stdout o en stderr. En el siguiente ejemplo, se registran los
valores de las variables de entorno y el objeto de evento.
Example lambda_function.rb
# lambda_function.rb

puts "## ENVIRONMENT VARIABLES"
puts ENV.to_a
puts "## EVENT"
puts event.to_a
end
Para obtener registros más detallados, utilice la biblioteca de registro.
require 'logger'

logger = Logger.new($stdout)
logger.info('## ENVIRONMENT VARIABLES')
logger.info(ENV.to_a)
372
Registro
logger.info('## EVENT')
logger.info(event)
event.to_a
end
La salida de logger incluye la marca de tiempo, el ID de proceso, el nivel de registro y el ID de solicitud.
I, [2019-10-26T10:04:01.689856 #8] INFO 6573a3a0-2fb1-4e78-a582-2c769282e0bd -- : ## EVENT

I, [2019-10-26T10:04:01.689874 #8] INFO 6573a3a0-2fb1-4e78-a582-2c769282e0bd -- :
{"key1"=>"value1", "key2"=>"value2", "key3"=>"value3"}
CloudWatch Logs.


{
"StatusCode": 200,
"LogResult":
}

373
START RequestId: 50aba555-99c8-4b21-8358-644ee996a05f Version: $LATEST

## ENVIRONMENT VARIABLES
AWS_LAMBDA_FUNCTION_VERSION
$LATEST
AWS_LAMBDA_LOG_GROUP_NAME
/aws/lambda/my-function
AWS_LAMBDA_LOG_STREAM_NAME
2020/01/31/[$LATEST]3f34xmpl069f4018b4a773bcfe8ed3f9
AWS_EXECUTION_ENV
AWS_Lambda_ruby2.5
...
## EVENT
key
value
END RequestId: 50aba555-xmpl-4b21-8358-644ee996a05f
REPORT RequestId: 50aba555-xmpl-4b21-8358-644ee996a05f Duration: 12.96 ms Billed Duration:
100 ms Memory Size: 128 MB Max Memory Used: 48 MB Init Duration: 117.86 ms
XRAY TraceId: 1-5e34a246-2a04xmpl0fa44eb60ea08c5f SegmentId: 454xmpl46ca1c7d3 Sampled: true
El tiempo de ejecución de Ruby registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles.

evento.
comandos.
Secciones

CloudWatch Logs.
374
Mediante AWS CLI

Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}

#!/bin/bash
sleep 15
out) --limit 5
375
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
}
],
}
Errores de funciones AWS Lambda en Ruby

Example function.rb
376
Errores
puts "Processing event..."

[1, 2, 3].first("two")
"Success"
end
Este código da como resultado un error de tipo. Lambda detecta el error y genera un documento JSON con
campos para el mensaje de error, el tipo y el seguimiento de la pila.
{
"errorMessage": "no implicit conversion of String into Integer",
"errorType": "Function<TypeError>",
"stackTrace": [
"/var/task/function.rb:3:in `first'",
"/var/task/function.rb:3:in `handler'"
]
}

{
"StatusCode": 200,
}
$ cat out.json
{"errorMessage":"no implicit conversion of String into
Integer","errorType":"Function<TypeError>","stackTrace":["/var/task/function.rb:3:in
`first'","/var/task/function.rb:3:in `handler'"]}
Note

START RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3 Version: $LATEST
Processing event...
Error raised from handler method
{
"errorMessage": "no implicit conversion of String into Integer",
"errorType": "Function<TypeError>",
"stackTrace": [
"/var/task/function.rb:3:in `first'",
"/var/task/function.rb:3:in `handler'"
]
}
END RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3
377
Tracing
REPORT RequestId: 5ce6a15a-f156-11e8-b8aa-25371a5ca2a3 Duration: 22.74 ms Billed

Ruby (p. 372).
En función del origen de eventos, AWS Lambda podría volver a intentar la ejecución de la función de
Lambda que ha generado un error. Por ejemplo, si Kinesis es el origen de eventos, AWS Lambda reintenta
la invocación que produce errores hasta que la función de Lambda se ejecute correctamente o hasta que
los registros del flujo caduquen. Para obtener más información acerca de los reintentos, consulte Control
de errores y reintentos automáticos en AWS Lambda (p. 119).
Instrumentación del código Ruby en AWS Lambda



378
Tracing
Precios
Para registrar detalles sobre las llamadas que su controlador realiza a otros recursos y servicios, use el
SDK de X-Ray para Ruby. Para obtener el SDK, agregue el paquete aws-xray-sdk a las dependencias
de su aplicación.
Example blank-ruby/function/Gemfile
# Gemfile
source 'https://rubygems.org'
gem 'aws-xray-sdk', '0.11.4'

gem 'aws-sdk-lambda', '1.39.0'
gem 'test-unit', '3.3.5'
Para instrumentar clientes SDK de AWS, se requiere el módulo aws-xray-sdk/lambda después de

crear un cliente en el código de inicialización.
Example blank-ruby/function/lambda_function.rb: Seguimiento de un cliente SDK de AWS
require 'logger'
require 'json'
require 'aws-sdk-lambda'
$client = Aws::Lambda::Client.new()
$client.get_account_settings()
379
require 'aws-xray-sdk/lambda'
def lambda_handler(event:, context:)

logger = Logger.new($stdout)
...

con anotaciones y metadatos. Para obtener más información, consulte SDK de X-Ray para Ruby en Guía
Secciones

Lambda

380
function».

publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...

Resources:
function:
Properties:
Tracing: Active
...

de Lambda (p. 76).

SDK para Ruby de X-Ray.
Resources:
function:
381
Properties:
CodeUri: function/.
Tracing: Active
Layers:
- !Ref libs
...
libs:
Properties:
LayerName: blank-ruby-lib
Description: Dependencies for the blank-ruby sample app.
ContentUri: lib/.
CompatibleRuntimes:
- ruby2.5
de implementación.
ejemplo blank-ruby.
382

con Java
Puede ejecutar Código Java en AWS Lambda. Lambda proporciona tiempos de ejecución (p. 130) para
Java que ejecutan código para procesar eventos. El código se ejecuta en un entorno de Amazon Linux que
incluye las credenciales de AWS de un rol de AWS Identity and Access Management (IAM) administrado
por usted.
Lambda admite los siguientes entornos de ejecución de Java.
Runtimes de Java
Nombre Identificador JDK Sistema operativo
Java 11 java11 amazon-corretto-11 Amazon Linux 2
Java 8 java8 java-1.8.0-openjdk Amazon Linux



Para crear una función de Java


• Runtime (Tiempo de ejecución): Java 11.
383
Aplicaciones de ejemplo

La consola crea una función de Lambda con una clase de controlador denominada Hello. Dado que Java
es un lenguaje compilado, no puede ver ni editar el código fuente en la consola de Lambda, pero puede
modificar su configuración, invocarla y configurar disparadores.
Note
aplicaciones de ejemplo (p. 384) disponibles en el repositorio de GitHub de esta guía.
La clase Hello cuenta con una función denominada handleRequest que toma un objeto de evento
y un objeto context. Esta es la función de controlador (p. 392) a la que llama Lambda cuando se
invoca la función. El tiempo de ejecución de la función de Java obtiene los eventos de invocación
de Lambda y se los pasa al controlador. En la configuración de función, el valor de controlador es
example.Hello::handleRequest.
Para actualizar el código de la función, cree un paquete de implementación, que es un archivo ZIP que
contiene el código de la función. A medida que avanza su función de desarrollo, querrá almacenar su
código de función en el control del código fuente, agregar bibliotecas y automatizar las implementaciones.
Comience creando un paquete de implementación (p. 386) y actualizando el código en la línea de
comandos.

Temas
• Aplicaciones de ejemplo de Java para AWS Lambda (p. 384)
• Controlador de funciones de AWS Lambda Java (p. 392)
• Objeto context de AWS Lambda en Java (p. 396)
• Registro de funciones de AWS Lambda en Java (p. 398)
• Instrumentación del código Java en AWS Lambda (p. 409)
• Creación de un paquete de implementación con Eclipse (p. 414)
Aplicaciones de ejemplo de Java para AWS

Lambda
El repositorio de GitHub para esta guía ofrece aplicaciones de ejemplo en las que se muestra el uso
de Java en AWS Lambda. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la
implementación y la limpieza, una plantilla de AWS CloudFormation y recursos de soporte.
384
Aplicaciones de ejemplo
variables de entorno, las capas, el seguimiento de AWS X-Ray, las pruebas unitarias y el SDK de AWS.
• java-events: función de Java mínima que utiliza la biblioteca aws-lambda-java-events (p. 386) con tipos
de eventos que no requieren el SDK de AWS como dependencia, como Amazon API Gateway.
• java-events-v1sdk: función de Java que utiliza la biblioteca aws-lambda-java-events (p. 386) con tipos
de eventos que requieren el SDK de AWS como dependencia (Amazon Simple Storage Service, Amazon
DynamoDB y Amazon Kinesis).
Utilice la aplicación de ejemplo de blank-java para aprender los conceptos básicos o como punto
de partida para su propia aplicación. Muestra el uso de las bibliotecas Java de Lambda, las variables
de entorno, el SDK de AWS y el SDK de AWS X-Ray. Utiliza una capa de Lambda para empaquetar
sus dependencias por separado del código de función, lo que acelera los tiempos de implementación
cuando está iterando en su código de función. El proyecto requiere una configuración mínima y se puede
implementar desde la línea de comandos en menos de un minuto.
Las demás aplicaciones de ejemplo muestran otras configuraciones de compilación, interfaces de

controlador y casos de uso para servicios que se integran con Lambda. El ejemplo de java-basic
muestra una función con dependencias mínimas. Puede utilizar este ejemplo para los casos en los que
no necesite bibliotecas adicionales como el SDK de AWS y puede representar la entrada y la salida de su
función con tipos Java estándar. Para probar un tipo de controlador diferente, puede cambiar simplemente
la configuración del controlador en la función.
Example java-basic/src/main/java/example/HandlerStream.java: controlador de flujo
// Handler value: example.HandlerStream

public class HandlerStream implements RequestStreamHandler {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context
context) throws IOException
{
LambdaLogger logger = context.getLogger();
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream,
Charset.forName("US-ASCII")));
PrintWriter writer = new PrintWriter(new BufferedWriter(new
OutputStreamWriter(outputStream, Charset.forName("US-ASCII"))));
try
{
HashMap event = gson.fromJson(reader, HashMap.class);
logger.log("STREAM TYPE: " + inputStream.getClass().toString());
385
logger.log("EVENT TYPE: " + event.getClass().toString());

writer.write(gson.toJson(event));
...
Los ejemplos java-events y java-events-v1sdk muestran el uso de los tipos de evento

proporcionados por la biblioteca aws-lambda-java-events. Estos tipos representan los documentos
de eventos que los servicios de AWS (p. 163) envían a su función. java-events incluye controladores
para tipos que no requieren dependencias adicionales. Para tipos de eventos como DynamodbEvent
que requieren tipos de AWS SDK for Java, java-events-v1sdk incluye el SDK en su configuración de
compilación.
Example java-events-v1sdk/src/main/java/example/HandlerDynamoDB.java: registros DynamoDB
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent;
import com.amazonaws.services.lambda.runtime.events.DynamodbEvent.DynamodbStreamRecord;
import com.amazonaws.services.dynamodbv2.model.Record;
...
// Handler value: example.HandlerDynamoDB
public class HandlerDynamoDB implements RequestHandler<DynamodbEvent, String>{
private static final Logger logger = LoggerFactory.getLogger(HandlerDynamoDB.class);
@Override
public String handleRequest(DynamodbEvent event, Context context)
{
String response = new String("200 OK");
for (DynamodbStreamRecord record : event.getRecords()){
logger.info(record.getEventID());
logger.info(record.getEventName());
logger.info(record.getDynamodb().toString());
}
...
Para conocer más detalles, consulte los otros temas de este capítulo.

Java
Un paquete de implementación es un archivo ZIP que contiene el código y las dependencias de la función
compilados. Puede cargar el paquete directamente en Lambda o utilizar un bucket de Amazon S3 y,
a continuación, cargarlo en Lambda. Si el paquete de implementación tiene más de 50 MB, debe usar
Amazon S3.
AWS Lambda proporciona las siguientes bibliotecas de funciones de Java:
• com.amazonaws:aws-lambda-java-core (obligatoria): define interfaces de métodos de controlador y el

objeto contextual que el entorno de ejecución pasa al controlador. Si define sus propios tipos de entrada,
esta es la única biblioteca que necesita.
• com.amazonaws:aws-lambda-java-events: tipos de entrada de eventos procedentes de servicios que
invocan funciones de Lambda.
• com.amazonaws:aws-lambda-java-log4j2: biblioteca de appender de Log4j 2 que puede usar para
agregar el ID solicitado en la invocación actual a los registros de funciones (p. 398).
Estas bibliotecas están disponibles en el repositorio central de Maven. Agréguelas a la definición de la

compilación de la siguiente manera.
386
Gradle
dependencies {
implementation 'com.amazonaws:aws-lambda-java-core:1.2.1'
implementation 'com.amazonaws:aws-lambda-java-events:2.2.9'
runtimeOnly 'com.amazonaws:aws-lambda-java-log4j2:1.2.0'
}
Maven
<dependencies>
<dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-lambda-java-core</artifactId>
<version>1.2.1</version>
</dependency>
<dependency>
<artifactId>aws-lambda-java-events</artifactId>
</dependency>
<dependency>
<artifactId>aws-lambda-java-log4j2</artifactId>
</dependency>
</dependencies>
Para crear un paquete de implementación, compile el código de función y las dependencias en un único
archivo ZIP o Java Archive (JAR). En el caso de Gradle, use el tipo de compilación Zip (p. 388). En el
caso de Maven, use el complemento Maven Shade (p. 388).
Note
Puede cargar el paquete de implementación a través de la consola de Lambda, la API de Lambda o AWS
SAM.
Para cargar un paquete de implementación con la consola de Lambda

3. En Function code (Código de función), elija Upload (Cargar).
4. Cargue el paquete de implementación.
Secciones
• Compilación de un paquete de implementación con Gradle (p. 388)
• Compilación de un paquete de implementación con Maven (p. 388)
• Carga de un paquete de implementación con la API de Lambda (p. 390)
• Carga de un paquete de implementación con AWS SAM (p. 391)
387
Compilación de un paquete de implementación con Gradle
Compilación de un paquete de implementación con

Gradle
Utilice el tipo de compilación Zip para crear un paquete de implementación con el código de la función y
las dependencias.
Example build.gradle: tarea de compilación
task buildZip(type: Zip) {

from compileJava
from processResources
into('lib') {
from configurations.runtimeClasspath
}
}
Esta configuración de compilación produce un paquete de implementación en la carpeta build/

distributions. La tarea compileJava compila las clases de la función. La tarea processResources
copia las bibliotecas del classpath de la compilación en una carpeta llamada lib.
Example build.gradle: dependencias
dependencies {
implementation platform('software.amazon.awssdk:bom:2.10.73')
implementation 'software.amazon.awssdk:lambda'
implementation 'com.google.code.gson:gson:2.8.6'
implementation 'org.apache.logging.log4j:log4j-api:2.13.0'
implementation 'org.apache.logging.log4j:log4j-core:2.13.0'
runtimeOnly 'org.apache.logging.log4j:log4j-slf4j18-impl:2.13.0'
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
}
Lambda carga los archivos JAR en orden alfabético Unicode. Si hay varios archivos JAR en la carpeta lib
que contienen la misma clase, se utiliza el primero. Puede utilizar el siguiente script de shell para identificar
las clases duplicadas.
Example test-zip.sh
mkdir -p expanded
unzip path/to/my/function.zip -d expanded
find ./expanded/lib -name '*.jar' | xargs -n1 zipinfo -1 | grep '.*.class' | sort | uniq -c
| sort
Compilación de un paquete de implementación con

Maven
Para crear un paquete de implementación con Maven, use el complemento Maven Shade. El complemento
crea un archivo JAR que contiene el código compilado de la función y todas sus dependencias.
Example pom.xml: configuración del complemento
<plugin>
388
Compilación de un paquete de implementación con Maven
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
Para crear el paquete de implementación, utilice el comando mvn package.
[INFO] Scanning for projects...

[INFO] -----------------------< com.example:java-maven >-----------------------
[INFO] Building java-maven-function 1.0-SNAPSHOT
[INFO] --------------------------------[ jar ]---------------------------------
...
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ java-maven ---
[INFO] Building jar: target/java-maven-1.0-SNAPSHOT.jar
[INFO]
[INFO] --- maven-shade-plugin:3.2.2:shade (default) @ java-maven ---
[INFO] Including com.amazonaws:aws-lambda-java-core:jar:1.2.1 in the shaded jar.
[INFO] Including com.amazonaws:aws-lambda-java-events:jar:2.2.9 in the shaded jar.
[INFO] Including joda-time:joda-time:jar:2.6 in the shaded jar.
[INFO] Including com.google.code.gson:gson:jar:2.8.6 in the shaded jar.
[INFO] Replacing original artifact with shaded artifact.
[INFO] Replacing target/java-maven-1.0-SNAPSHOT.jar with target/java-maven-1.0-SNAPSHOT-
shaded.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 8.321 s
[INFO] Finished at: 2020-03-03T09:07:19Z
[INFO] ------------------------------------------------------------------------
Este comando genera un archivo JAR en la carpeta target.
Si utiliza la biblioteca de appender (aws-lambda-java-log4j2), también debe configurar un

transformador para el complemento Maven Shade. La biblioteca de transformadores combina versiones de
un archivo de caché que aparecen tanto en la biblioteca de appender como en Log4j.
Example pom.xml: configuración del complemento con el appender Log4j 2
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<configuration>
<createDependencyReducedPom>false</createDependencyReducedPom>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
389
Carga de un paquete de
implementación con la API de Lambda
<transformers>
<transformer
implementation="com.github.edwgiz.maven_shade_plugin.log4j2_cache_transformer.PluginsCacheFileTransfor
</transformer>
</transformers>
</configuration>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>com.github.edwgiz</groupId>
<artifactId>maven-shade-plugin.log4j2-cachefile-transformer</artifactId>
</dependency>
</dependencies>
</plugin>
Carga de un paquete de implementación con la API de

Lambda
Para actualizar el código de una función con la AWS CLI o el SDK de AWS, utilice la operación
UpdateFunctionCode (p. 659) de la API. En el caso de la CLI de AWS, utilice el comando update-
function-code. El siguiente comando carga un paquete de implementación llamado my-
function.zip en el directorio actual.

fileb://my-function.zip
{
"Runtime": "java8",
"Handler": "example.Handler",
"TracingConfig": {
"Mode": "Active"
},
...
}
Si el paquete de implementación es mayor que 50 MB, no puede cargarlo directamente. Cárguelo en un

bucket de Amazon S3 y haga que Lambda apunte al objeto. Los comandos de ejemplo siguientes cargan
un paquete de implementación en un bucket llamado my-bucket y lo utilizan para actualizar el código de
una función.
~/my-function$ aws s3 cp my-function.zip s3://my-bucket

upload: my-function.zip to s3://my-bucket/my-function
~/my-function$ aws lambda update-function-code --function-name my-function \
--s3-bucket my-bucket --s3-key my-function.zip
{
"Runtime": "java8",
"Handler": "example.Handler",
"TracingConfig": {
390
Carga de un paquete de implementación con AWS SAM
"Mode": "Active"
},
...
}
Puede utilizar este método para cargar paquetes de funciones hasta alcanzar 250 MB (descomprimidos).
Carga de un paquete de implementación con AWS

SAM
Puede usar el Modelo de aplicación sin servidor de AWS para automatizar las implementaciones
del código de función, la configuración y las dependencias. AWS SAM es una extensión de AWS
CloudFormation que proporciona una sintaxis simplificada para definir aplicaciones sin servidor. En la
siguiente plantilla de ejemplo, se define una función con un paquete de implementación en el directorio
build/distributions que usa Gradle.
Resources:
function:
Properties:
CodeUri: build/distributions/java-basic.zip
Handler: example.Handler
Runtime: java8
Description: Java function
MemorySize: 512
Timeout: 10
Policies:
- AWSLambdaVPCAccessExecutionRole
Tracing: Active
Para crear la función, utilice los comandos package y deploy. Estos comandos son personalizaciones de
la CLI de AWS. Contienen otros comandos que van a cargar el paquete de implementación en Amazon S3,
reescribir la plantilla con el URI del objeto y actualizar el código de la función.
El siguiente script de ejemplo ejecuta una compilación de Gradle y carga el paquete de implementación
que crea. Crea una pila de AWS CloudFormation la primera vez que la ejecuta. Si la pila ya existe, el script
la actualiza.
Example deploy.sh
#!/bin/bash
set -eo pipefail
aws cloudformation package --template-file template.yml --s3-bucket MY_BUCKET --output-
template-file out.yml
aws cloudformation deploy --template-file out.yml --stack-name java-basic --capabilities
CAPABILITY_NAMED_IAM
Para ver un ejemplo completo, consulte las siguientes aplicaciones.
391
Controlador
Controlador de funciones de AWS Lambda Java

El controlador de la función Lambda es el método del código de la función que procesa eventos. Cuando
se invoca una función, Lambda ejecuta el método del controlador. Si el controlador existe o devuelve una
respuesta, pasará a estar disponible para gestionar otro evento.
En el siguiente ejemplo, la clase Handler define un método de controlador llamado handleRequest. El

método handler toma un evento y un objeto contextual como entrada y devuelve una cadena.
package example;
import com.amazonaws.services.lambda.runtime.Context
import com.amazonaws.services.lambda.runtime.RequestHandler
import com.amazonaws.services.lambda.runtime.LambdaLogger
...
// Handler value: example.Handler

public class Handler implements RequestHandler<Map<String,String>, String>{
@Override
public String handleRequest(Map<String,String> event, Context context)
{
// log execution details
logger.log("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
logger.log("CONTEXT: " + gson.toJson(context));
// process event
logger.log("EVENT: " + gson.toJson(event));
return response;
}
}
El entorno de ejecución de Lambda (p. 130) recibe un evento como una cadena con formato JSON y lo
convierte en un objeto. Pasa el objeto del evento al controlador de la función junto con un objeto contextual
que proporciona detalles sobre la invocación y la función. Es usted quien debe decirle al entorno de
ejecución qué método va a invocar estableciendo el parámetro del controlador en la configuración de la
función.
Formatos de controlador
• package.Class::method: formato completo. Por ejemplo: example.Handler::handleRequest.
392
Elección de los tipos de entrada y salida
• package.Class: formato abreviado para las funciones que implementan una interfaz de
controlador (p. 394). Por ejemplo: example.Handler.
Puede agregar un código de inicialización (p. 20) fuera del método del controlador para reutilizar los
recursos en diferentes invocaciones. Cuando el entorno de ejecución carga el controlador, ejecuta código
estático y el constructor de clases. Los recursos que se crean durante la inicialización permanecen en la
memoria entre las invocaciones y el controlador puede reutilizarlos miles de veces.
En el siguiente ejemplo, el registrador, el serializador y el cliente del SDK de AWS se crean cuando la
función sirve su primer evento. Los eventos que esta misma instancia de la función sirve posteriormente
son mucho más rápidos porque esos recursos ya existen.
Example Handler.java: código de inicialización

public class Handler implements RequestHandler<SQSEvent, String>{
private static final Logger logger = LoggerFactory.getLogger(Handler.class);
private static final Gson gson = new GsonBuilder().setPrettyPrinting().create();
private static final LambdaAsyncClient lambdaClient = LambdaAsyncClient.create();
...
@Override
public String handleRequest(SQSEvent event, Context context)
{
String response = new String();
// call Lambda API
logger.info("Getting account settings");
CompletableFuture<GetAccountSettingsResponse> accountSettings =
lambdaClient.getAccountSettings(GetAccountSettingsRequest.builder().build());
logger.info("ENVIRONMENT VARIABLES: " + gson.toJson(System.getenv()));
...
El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo fáciles de implementar en las
que se muestran diferentes tipos de controladores. Para obtener más información, consulte el final de este
tema (p. 395).
Secciones
• Elección de los tipos de entrada y salida (p. 393)
• Interfaces de controlador (p. 394)
• Ejemplo de código del controlador (p. 395)
Elección de los tipos de entrada y salida

Especifique el tipo de objeto al que se asigna el evento en la firma del método del controlador. En el
ejemplo anterior, el entorno de ejecución de Java deserializa el evento en un tipo que implementa la
interfaz Map<String,String>. Los mapas de cadena a cadena funcionan para eventos planos como los
siguientes:
Example Event.json: datos del tiempo
{
"temperatureK": 281,
"windKmh": -3,
"humidityPct": 0.55,
"pressureHPa": 1020
}
393
Interfaces de controlador
Sin embargo, el valor de cada campo debe ser una cadena o un número. Si el evento contiene un campo
que tiene un objeto como valor, el entorno de ejecución no puede deserializarlo y devuelve un error.
Elija un tipo de entrada que funcione con los datos del evento que procesa la función. Puede utilizar un tipo
básico, un tipo genérico o un tipo bien definido.
Tipos de entrada
• Integer, Long, Double, etc.: el evento es un número sin formato adicional; por ejemplo, 3.5. El
entorno de ejecución convierte el valor en un objeto del tipo especificado.
• String: el evento es una cadena JSON, incluidas las comillas; por ejemplo, "My string.". El tiempo
de ejecución convierte el valor (sin comillas) en un objeto String.
• Type, Map<String,Type>, etc.: el evento es un objeto JSON. El entorno de ejecución lo deserializa en
un objeto del tipo especificado o una interfaz.
• List<Integer>, List<String>, List<Object>, etc.: el evento es una matriz JSON. El entorno de
ejecución lo deserializa en un objeto del tipo especificado o una interfaz.
• InputStream: el evento es cualquier tipo JSON. El entorno de ejecución pasa una secuencia de bytes
del documento al controlador sin modificaciones. Usted deserializa la entrada y escribe la salida en una
secuencia de salida.
• Tipo de biblioteca: en el caso de los eventos enviados por los servicios de AWS, utilice los tipos de la
biblioteca aws-lambda-java-events (p. 386).
Si define su propio tipo de entrada, debería ser un objeto Java estándar (POJO) mutable y deserializable,
con un constructor predeterminado y unas propiedades predeterminadas para cada campo del evento. Las
claves del evento que no se asignan a una propiedad, así como las propiedades que no están incluidas en
el evento, se eliminan sin errores.
El tipo de salida puede ser un objeto o void. El entorno de ejecución serializa los valores devueltos en
texto. Si la salida es un objeto con campos, el entorno de ejecución lo serializa en un documento JSON. Si
se trata de un tipo que encapsula un valor primitivo, el tiempo de ejecución devuelve una representación de
texto de ese valor.
Interfaces de controlador
La biblioteca aws-lambda-java-core define dos interfaces para los métodos de controlador. Utilice las
interfaces proporcionadas para simplificar la configuración del controlador y validar la firma del método del
controlador en tiempo de compilación.
• com.amazonaws.services.lambda.runtime.RequestHandler
• com.amazonaws.services.lambda.runtime.RequestStreamHandler
La interfaz RequestHandler es un tipo genérico que toma dos parámetros: el tipo de entrada y el tipo de
salida. Los dos tipos deben ser objetos. Cuando se utiliza esta interfaz, el entorno de ejecución de Java
deserializa el evento en un objeto con el tipo de entrada y serializa la salida en texto. Utilice esta interfaz si
la serialización integrada funcione con los tipos de entrada y salida.
Example Handler.java: interfaz del controlador

@Override
394
Ejemplo de código del controlador
Para usar su propia serialización, implemente la interfaz RequestStreamHandler. Con esta interfaz,
Lambda pasa al controlador una secuencia de entrada y otra secuencia de salida. El controlador lee los
bytes de la secuencia de entrada, escribe en la secuencia de salida y devuelve void.
En el ejemplo siguiente se utilizan unos tipos de lectores y escritores almacenados en el búfer para trabajar
con las secuencias de entrada y salida. Utiliza la biblioteca Gson para la serialización y la deserialización.
Example HandlerStream.java
import com.amazonaws.services.lambda.runtime.RequestStreamHandler
...
// Handler value: example.HandlerStream
public class HandlerStream implements RequestStreamHandler {
@Override
public void handleRequest(InputStream inputStream, OutputStream outputStream, Context
context) throws IOException
{
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream,
Charset.forName("US-ASCII")));
PrintWriter writer = new PrintWriter(new BufferedWriter(new
OutputStreamWriter(outputStream, Charset.forName("US-ASCII"))));
try
{
HashMap event = gson.fromJson(reader, HashMap.class);
logger.log("STREAM TYPE: " + inputStream.getClass().toString());
writer.write(gson.toJson(event));
if (writer.checkError())
{
logger.log("WARNING: Writer encountered an error.");
}
}
catch (IllegalStateException | JsonSyntaxException exception)
{
logger.log(exception.toString());
}
finally
{
reader.close();
writer.close();
}
}
}
Ejemplo de código del controlador

diferentes tipos de controladores e interfaces. Cada una de las aplicaciones de ejemplo contiene scripts
para facilitar la implementación y la limpieza, una plantilla de AWS SAM y recursos de soporte.
395
Contexto
Las aplicaciones blank-java y s3-java toman un evento de un servicio de AWS como entrada y
devuelven una cadena. La aplicación java-basic contiene varios tipos de controladores:
• Handler.java: toma Map<String,String> como entrada.

• HandlerInteger.java: toma Integer como entrada.
• HandlerList.java: toma List<Integer> como entrada.
• HandlerStream.java: toma InputStream y OutputStream como entrada.
• HandlerString.java: toma String como entrada.
• HandlerWeatherData.java: toma un tipo personalizado como entrada.
Para probar diferentes tipos de controlador, solo tiene que cambiar el valor del controlador en la plantilla de
AWS SAM. Para obtener instrucciones detalladas, consulte el archivo readme (léame) de la aplicación de
ejemplo.
Objeto context de AWS Lambda en Java

Métodos de context
• getRemainingTimeInMillis(): Devuelve el número de milisegundos que faltan antes de que se

• getFunctionName() – Devuelve el nombre de la función de Lambda.
• getFunctionVersion() – Devuelve la versión (p. 70) de la función.
• getInvokedFunctionArn() – Devuelve el nombre de recurso de Amazon (ARN) que se utiliza para
invocar la función. Indica si el invocador ha especificado un alias o un número de versión.
• getMemoryLimitInMB() – Devuelve la cantidad de memoria que se asigna para la función.
• getAwsRequestId() – Devuelve el identificador de la solicitud de invocación.
• getLogGroupName() – Devuelve el grupo de registros de la función.
• getLogStreamName() – Devuelve el flujo de registro para la instancia de la función.
• getIdentity() – (aplicaciones móviles) Devuelve información acerca de la identidad de Amazon
Cognito que ha autorizado la solicitud.
• getClientContext() – (aplicaciones móviles) Devuelve el contexto del cliente proporcionado a
Lambda por parte de la aplicación del cliente.
• getLogger(): devuelve el objeto logger (p. 398) para la función.
En el ejemplo siguiente, se muestra una función que utiliza el objeto contextual para acceder al registrador
de Lambda.
package example;
396
Contexto
import com.amazonaws.services.lambda.runtime.RequestHandler
...

@Override
{
// process event
return response;
}
}
La función serializa el objeto contextual en JSON y lo registra en su secuencia de registro.
Example salida del registro
START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST

...
CONTEXT:
{
"memoryLimit": 512,
"awsRequestId": "6bc28136-xmpl-4365-b021-0ce6b2e64ab0",
"functionName": "java-console",
...
}
...
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration:
La interfaz del objeto contextual está disponible en la biblioteca aws-lambda-java-core. Puede implementar
esta interfaz para crear una clase contextual para las pruebas. En el ejemplo siguiente, se muestra una
clase contextual que devuelve valores ficticios para la mayoría de las propiedades y un registrador de
pruebas en funcionamiento.
Example src/test/java/example/TestContext.java
package example;
import com.amazonaws.services.lambda.runtime.CognitoIdentity;
import com.amazonaws.services.lambda.runtime.ClientContext;
public class TestContext implements Context{

public TestContext() {}
public String getAwsRequestId(){
return new String("495b12a8-xmpl-4eca-8168-160484189f99");
}
public String getLogGroupName(){
return new String("/aws/lambda/my-function");
397
Contexto en aplicaciones de ejemplo
}
...
public LambdaLogger getLogger(){
return new TestLogger();
}
Para obtener más información sobre los registros, consulte Registro de funciones de AWS Lambda en
Java (p. 398).
Contexto en aplicaciones de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso del
objeto contextual. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación
y la limpieza, una plantilla de Modelo de aplicación sin servidor de AWS (AWS SAM) y recursos de soporte.
Todas las aplicaciones de ejemplo tienen una clase de contextual para las pruebas unitarias. La aplicación
java-basic muestra como utilizar el objeto contextual para obtener un registrador. Utiliza SLF4J y Log4J
2 para proporcionar un registrador que funcione con pruebas unitarias locales.
Registro de funciones de AWS Lambda en Java

Para generar registros desde el código de función, puede utilizar los métodos de java.lang.System o
cualquier módulo de registro que escriba en stdout o en stderr. La biblioteca aws-lambda-java-
core (p. 386) tiene una clase de registrador llamada LambdaLogger a la que se puede acceder desde el
objeto contextual. La clase de registrador admite registros multilínea.
En el ejemplo siguiente se utiliza el registrador LambdaLogger proporcionado por el objeto contextual.

public class Handler implements RequestHandler<Object, String>{
@Override
public String handleRequest(Object event, Context context)
398
Registro
{
String response = new String("SUCCESS");
// process event
return response;
}
}

ENVIRONMENT VARIABLES:
{
"_HANDLER": "example.Handler",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
"AWS_LAMBDA_FUNCTION_MEMORY_SIZE": "512",
...
}
CONTEXT:
{
"memoryLimit": 512,
...
}
EVENT:
{
"records": [
{
"messageId": "19dd0b57-xmpl-4ac1-bd88-01bbb068cb78",
"receiptHandle": "MessageReceiptHandle",
"body": "Hello from SQS!",
...
}
]
}
END RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Duration: 198.50 ms Billed Duration:
El tiempo de ejecución de Java registra las líneas START, END y REPORT de cada invocación. La línea del
informe proporciona los siguientes detalles:

evento.
399
comandos.
Secciones
• Registro avanzado con Log4j 2 y SLF4J (p. 402)
• Código de registro de ejemplo (p. 404)

CloudWatch Logs.

Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}

400
Mediante AWS CLI

#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
401
}
],
}
Registro avanzado con Log4j 2 y SLF4J

Para personalizar la salida del registro, posibilitar el registro durante las pruebas unitarias y registrar las
llamadas del SDK de AWS, utilice Apache Log4j 2 con SLF4J. Log4j es una biblioteca de registros para
programas Java que permite configurar diversos niveles de registro y utilizar bibliotecas de appender.
SLF4J es una biblioteca de fachadas que permite cambiar la biblioteca empleada sin modificar el código de
la función.
Para agregar el ID de la solicitud a los registros de la función, use el appender de la biblioteca aws-lambda-
java-log4j2 (p. 386). En el ejemplo siguiente, se muestra un archivo de configuración de Log4j 2 que
agrega una marca temporal y un ID de solicitud a todos los registros.
Example src/main/resources/log4j2.xml: configuración de appender
<Configuration status="WARN">
<Appenders>
<Lambda name="Lambda">
<PatternLayout>
<pattern>%d{yyyy-MM-dd HH:mm:ss} %X{AWSRequestId} %-5p %c{1} - %m%n</pattern>
</PatternLayout>
</Lambda>
</Appenders>
<Loggers>
<Root level="INFO">
<AppenderRef ref="Lambda"/>
</Root>
<Logger name="software.amazon.awssdk" level="WARN" />
<Logger name="software.amazon.awssdk.request" level="DEBUG" />
</Loggers>
</Configuration>
Con esta configuración, en cada línea se antepone la fecha, la hora, el ID de solicitud, el nivel de registro y
el nombre de clase.
Example formato de registro con appender

2020-03-18 08:52:43 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 INFO Handler - ENVIRONMENT
VARIABLES:
{
"_HANDLER": "example.Handler",
"AWS_EXECUTION_ENV": "AWS_Lambda_java8",
...
}
2020-03-18 08:52:43 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 INFO Handler - CONTEXT:
402
Registro avanzado con Log4j 2 y SLF4J
{
"memoryLimit": 512,
...
}
SLF4J es una biblioteca de fachadas para los registros de código Java. En el código de la función,
se utiliza la fábrica del registrador de SLF4J para recuperar un registrador con métodos para niveles
de registro como info() y warn(). En la configuración de compilación, puede incluir la biblioteca
de registros y el adaptador de SLF4J en el classpath. Si cambia las bibliotecas en la configuración de
compilación, puede cambiar el tipo de registrador sin necesidad de modificar el código de la función. Es
necesario utilizar SLF4J para capturar registros de SDK para Java.
En el siguiente ejemplo, la clase de controlador utiliza SLF4J para recuperar un registrador.
Example src/main/java/example/Handler.java: el registro se realiza con SLF4J
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class Handler implements RequestHandler<SQSEvent, String>{
private static final Logger logger = LoggerFactory.getLogger(Handler.class);
LambdaAsyncClient lambdaClient = LambdaAsyncClient.create();
@Override
public String handleRequest(SQSEvent event, Context context)
{
String response = new String();
// call Lambda API
logger.info("Getting account settings");
CompletableFuture<GetAccountSettingsResponse> accountSettings =
lambdaClient.getAccountSettings(GetAccountSettingsRequest.builder().build());
logger.info("ENVIRONMENT VARIABLES: {}", gson.toJson(System.getenv()));
...
La configuración de compilación toma dependencias del entorno de ejecución del appender de Lambda y
del adaptador de SLF4J, y dependencias de implementación de Log4J 2.
Example build.gradle: dependencias de registro
dependencies {
implementation platform('com.amazonaws:aws-xray-recorder-sdk-bom:2.4.0')
implementation 'com.amazonaws:aws-xray-recorder-sdk-core'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-core'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-v2'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-v2-instrumentor'
implementation 'com.google.code.gson:gson:2.8.6'
implementation 'org.apache.logging.log4j:log4j-api:2.13.0'
implementation 'org.apache.logging.log4j:log4j-core:2.13.0'
runtimeOnly 'org.apache.logging.log4j:log4j-slf4j18-impl:2.13.0'
testImplementation 'org.junit.jupiter:junit-jupiter-api:5.6.0'
testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.6.0'
}
403
Código de registro de ejemplo
Cuando ejecuta el código localmente para realizar pruebas, el objeto contextual con el registrador de
Lambda no está disponible y no hay ningún ID de solicitud que el appender de Lambda pueda utilizar. Para
ver ejemplos de configuraciones de prueba, consulte las aplicaciones de la siguiente sección.
Código de registro de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso
de diferentes configuraciones de registro. Cada una de las aplicaciones de ejemplo contiene scripts para
facilitar la implementación y la limpieza, una plantilla de AWS SAM y recursos de soporte.
En la aplicación de ejemplo java-basic, se muestra una configuración de registro mínima que admite
pruebas de registro. El código del controlador utiliza el registrador de LambdaLogger proporcionado por
el objeto contextual. En el caso de las pruebas, la aplicación utiliza una clase TestLogger personalizada
que implementa la interfaz LambdaLogger con un registrador de Log4j 2. SLF4J se utiliza como fachada
para garantizar la compatibilidad con el SDK de AWS. Las bibliotecas de registro se excluyen de la salida
de compilación para mantener un tamaño de paquete de implementación pequeño.
La aplicación de ejemplo blank-java utiliza la configuración básica con los registros del SDK de AWS
y el appender de Log4j 2 de Lambda. Log4j 2 se utiliza en Lambda con un appender personalizado que
agrega el ID de solicitud de invocación a cada línea.
Errores de la función AWS Lambda en Java

Cuando la función genera un error, Lambda devuelve detalles sobre dicho error al invocador. El cuerpo de
la respuesta que devuelve Lambda contiene un documento JSON con el nombre del error, el tipo de error
y una matriz de marcos de pila. El cliente o el servicio que invocó la función puede solucionar el error o
pasarlo a un usuario final. Puede utilizar excepciones personalizadas para devolver información útil a los
usuarios en caso de que se produzcan errores en el cliente.
Example src/main/java/example/HandlerDivide.java: excepción en tiempo de ejecución
import java.util.List;
// Handler value: example.HandlerDivide

public class HandlerDivide implements RequestHandler<List<Integer>, Integer>{
@Override
public Integer handleRequest(List<Integer> event, Context context)
{
// process event
if ( event.size() != 2 )
404
Ver la salida de errores
{
throw new InputLengthException("Input must be an array that contains 2 numbers.");
}
int numerator = event.get(0);
int denominator = event.get(1);
return numerator/denominator;
}
}
Cuando se lanza la función InputLengthException, el entorno de ejecución de Java la serializa en el

siguiente documento.
Example documento de error (con espacios en blanco agregados)
{
"errorMessage":"Input must contain 2 numbers.",
"errorType":"java.lang.InputLengthException",
"stackTrace": [
"example.HandlerDivide.handleRequest(HandlerDivide.java:23)",
"example.HandlerDivide.handleRequest(HandlerDivide.java:14)"
]
}
En este en, InputLengthException es una excepción RuntimeException. La interfaz (p. 394)

RequestHandler no permite excepciones comprobadas. La interfaz RequestStreamHandler permite
que se generen errores IOException.
La instrucción return del ejemplo anterior también puede generar una excepción en tiempo de ejecución.
return numerator/denominator;
Este código puede devolver un error aritmético.
{"errorMessage":"/ by zero","errorType":"java.lang.ArithmeticException","stackTrace":
["example.HandlerDivide.handleRequest(HandlerDivide.java:28)","example.HandlerDivide.handleRequest(Hand
Secciones
• Ver la salida de errores (p. 405)
• Descripción de los tipos y orígenes de errores (p. 407)
• Administración de errores en los clientes (p. 408)
• Administración de errores en otros servicios de AWS (p. 408)
• Administración de errores en aplicaciones de ejemplo (p. 409)

Puede invocar la función con una carga prueba y ver la salida de errores utilizando la consola de Lambda,
la línea de comandos o el SDK de AWS. La salida de errores también se captura en los registros de
ejecución de la función y, si el seguimiento (p. 409) está habilitado, en AWS X-Ray.
Para ver la salida de errores en la consola de Lambda, invóquela con un evento de prueba.
Para invocar una función en la consola de Lambda
405

3. Elija Configure test events (Configurar eventos de prueba) en el menú desplegable situado junto al
botón Test (Prueba).
4. Elija una plantilla de evento que se ajuste a los eventos que procesa su función.
5. Asigne un nombre al evento de prueba y modifique la estructura de eventos según sea necesario.
6. Seleccione Create (Crear).
7. Elija Test.
La consola de Lambda invoca la función de forma sincrónica (p. 100) y muestra el resultado. Para ver la
respuesta, los registros y otra información, expanda la sección Details (Detalles).

{
"StatusCode": 200,
}
$ cat out.json
{"errorMessage":"Input must contain 2
numbers.","errorType":"java.lang.InputLengthException","stackTrace":
["example.HandlerDivide.handleRequest(HandlerDivide.java:23)","example.HandlerDivide.handleRequest(Han
$ aws lambda invoke --function-name my-function --payload "[100,0]" out.json --log-type

Tail \
START RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f Version: $LATEST
EVENT: [
100,
0
]EVENT TYPE: class java.util.ArrayList/ by zero: java.lang.ArithmeticException
java.lang.ArithmeticException: / by zero
at example.HandlerDivide.handleRequest(HandlerDivide.java:28)
at example.HandlerDivide.handleRequest(HandlerDivide.java:13)
END RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f

REPORT RequestId: 081f7522-xmpl-48e2-8f67-96686904bb4f Duration: 4.20 ms Billed
XRAY TraceId: 1-5e73162b-1919xmpl2592f4549e1c39be SegmentId: 3dadxmpl48126cb8
Sampled: true
406
Descripción de los tipos y orígenes de errores
Java (p. 398).
Descripción de los tipos y orígenes de errores

Cuando se invoca una función, varios subsistemas administran la solicitud, el evento, la salida y la
respuesta. Los errores pueden provenir del servicio de Lambda (errores de invocación) o de una instancia
de la función. Los errores de la función pueden ser excepciones devueltas por el código del controlador y
excepciones devueltas por el entorno de ejecución de Lambda.
El servicio Lambda recibe la solicitud de invocación y la valida. Comprueba los permisos, que el
documento del evento es un documento JSON válido y los valores de los parámetros. Si el servicio
Lambda encuentra algún error, devuelve un tipo de excepción, mensaje y código de estado HTTP que
indican la causa del error.
Note
Para ver una lista completa de los errores que puede devolver la operación Invoke de la API,
consulte los errores de Invoke (p. 589) en la referencia de la API de Lambda.
Los errores de la serie 4xx del servicio Lambda indican que se trata de un error que el invocador puede
corregir modificando la solicitud, solicitando permiso o intentándolo de nuevo. Los errores de la serie 5xx
indican un problema con el ser Lambda o un problema con la configuración o los recursos de la función.
Estos problemas no puede solucionarlos el invocador, pero el propietario de la función podría corregirlos.
Si una solicitud pasa la validación, Lambda la envía a una instancia de la función. El entorno de ejecución
convierte el documento del evento en un objeto y se lo pasa al código del controlador. Durante este
proceso, pueden producirse errores si, por ejemplo, el nombre del método del controlador no coincide con
la configuración de la función o si el tiempo de espera de la invocación se agotó antes de que el código del
controlador devolviera una respuesta. Los errores de tiempo de ejecución de Lambda tienen un formato
similar a los errores que devuelve el código, pero los devuelve el tiempo de ejecución.
En el ejemplo siguiente, el entorno de ejecución no puede deserializar el evento en un objeto. La entrada

es un tipo JSON válido, pero no coincide con el tipo que esperaba el método de controlador.
Example Error del tiempo de ejecución de Lambda
{
"errorMessage": "An error occurred during JSON parsing",
"errorType": "java.lang.RuntimeException",
"stackTrace": [],
"cause": {
"errorMessage": "com.fasterxml.jackson.databind.exc.InvalidFormatException: Can not
construct instance of java.lang.Integer from String value '1000,10': not a valid Integer
value\n at [Source: lambdainternal.util.NativeMemoryAsInputStream@35fc6dc4; line: 1,
column: 1] (through reference chain: java.lang.Object[0])",
"errorType": "java.io.UncheckedIOException",
"stackTrace": [],
"cause": {
"errorMessage": "Can not construct instance of java.lang.Integer
from String value '1000,10': not a valid Integer value\n at [Source:
lambdainternal.util.NativeMemoryAsInputStream@35fc6dc4; line: 1, column: 1] (through
reference chain: java.lang.Object[0])",
"errorType": "com.fasterxml.jackson.databind.exc.InvalidFormatException",
"stackTrace": [
"com.fasterxml.jackson.databind.exc.InvalidFormatException.from(InvalidFormatException.java:55)",
"com.fasterxml.jackson.databind.DeserializationContext.weirdStringException(DeserializationContext.jav
...
]
407
Administración de errores en los clientes
}
}
}
En los errores del entorno de ejecución de Lambda y en otros errores de la función, el servicio Lambda
no devuelve ningún código de error. Un código de estado de la serie 2xx indica que el servicio Lambda
aceptó la solicitud. En lugar de un código de error, Lambda indica el error incluyendo el encabezado X-
Amz-Function-Error en la respuesta.
En las invocaciones asíncronas, los eventos se ponen en cola antes de que Lambda los envíe a la
función. En las solicitudes válidas, Lambda devuelve una respuesta correcta inmediatamente y agrega el
evento a la cola. Después, Lambda lee los eventos de la cola e invoca la función. Si se produce un error,
Lambda vuelve a intentarlo con un comportamiento que variará según el tipo de error. Para obtener más
información, consulte Invocación asincrónica (p. 101).
Administración de errores en los clientes

Los clientes que invocan funciones Lambda pueden elegir si desean ocuparse de los errores o pasarlos
al usuario final. El comportamiento adecuado en la administración de errores dependerá del tipo de
aplicación, la audiencia y el origen del error. Por ejemplo, si se produce un error en una invocación con el
código 429 (demasiadas solicitudes), la CLI de AWS lo volverá a intentar hasta 4 veces antes de mostrar
un error al usuario.

An error occurred (TooManyRequestsException) when calling the Invoke operation (reached max
retries: 4): Rate Exceeded.
En otros errores de invocación, el comportamiento correcto dependerá del código de respuesta. La serie
5xx pueden indicar una condición temporal que puede resolverse sin que el usuario tenga que hacer nada.
Volver a intentarlo podría funcionar o no. Los errores de la serie 4xx que no son 429 suelen indicar un
error con la solicitud. No es probable que volver a intentarlo funcione.
En los errores de la función, el cliente puede procesar el documento de error y mostrar el mensaje de error
en un formato sencillo. Una aplicación basada en navegador podría mostrar el mensaje y el tipo de error,
pero omitir el seguimiento de la pila. La CLI de AWS guarda el objeto de error en el archivo de salida y
muestra en su lugar un documento generado a partir de los encabezados de respuesta.
$ aws lambda invoke --function-name my-function --payload '[1000]' out.json

{
"StatusCode": 200,
}
Example out.json
{"errorMessage":"Input must be an array that contains 2

numbers.","errorType":"example.InputLengthException","stackTrace":
["example.HandlerDivide.handleRequest(HandlerDivide.java:22)","example.HandlerDivide.handleRequest(Hand
Administración de errores en otros servicios de AWS

Cuando un servicio de AWS invoca la función, el servicio elige el tipo de invocación y el comportamiento
que va a adoptar respecto a los reintentos. Los servicios de AWS pueden invocar la función en función de
un calendario, en respuesta a un evento del ciclo de vida de un recurso o para atender una solicitud de un
408
Administración de errores en aplicaciones de ejemplo
usuario. Algunos servicios invocan funciones de forma asíncrona y permiten que Lambda administre los
errores, mientras que otros vuelven a intentarlo o pasan los errores al usuario.
Por ejemplo, API Gateway trata todos los errores de invocación y función como errores internos. Si la API
de Lambda rechaza la solicitud de invocación, API Gateway devuelve un código de error 500. Si la función
se ejecuta pero devuelve un error o devuelve una respuesta con un formato incorrecto, API Gateway
muestra un código de error 502. Para personalizar la respuesta del error, debe detectar errores en el
código y elaborar una respuesta en el formato que desee.
Para determinar el origen de un error y su causa, use AWS X-Ray. Con X-Ray, puede saber en qué
componente se produjo un error y ver los detalles sobre las excepciones. En el ejemplo siguiente, se
muestra un error de una función que generó una respuesta 502 de API Gateway.
Para empezar a utilizar X-Ray, habilite el seguimiento activo (p. 409) en las funciones.
Para obtener información detallada sobre otros errores del controlador de servicios, consulte los temas del
capítulo Utilización de AWS Lambda con otros servicios (p. 163).
Administración de errores en aplicaciones de ejemplo

los errores. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación y la
limpieza, una plantilla de Modelo de aplicación sin servidor de AWS (AWS SAM) y recursos de soporte.
La función java-basic incluye un controlador (HandlerDivide) que devuelve una excepción en tiempo
de ejecución personalizada. El controlador HandlerStream implementa RequestStreamHandler y
puede generar una excepción comprobada IOException.
Instrumentación del código Java en AWS Lambda

409
Tracing


Precios
410
Tracing
Para registrar los detalles sobre las llamadas a otros recursos y servicios que realiza la función, agregue
el SDK para Java de X-Ray a la configuración de compilación. En el siguiente ejemplo, se muestra una
configuración de compilación de Gradle que incluye las bibliotecas que permiten la instrumentación
automática de los clientes de AWS SDK para Java 2.x.
Example build.gradle: dependencias de seguimiento
dependencies {
implementation platform('com.amazonaws:aws-xray-recorder-sdk-bom:2.4.0')
implementation 'com.amazonaws:aws-xray-recorder-sdk-core'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-core'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-v2'
implementation 'com.amazonaws:aws-xray-recorder-sdk-aws-sdk-v2-instrumentor'
...
}

411
con anotaciones y metadatos. Para obtener más información, consulte SDK de AWS X-Ray para Java en
Guía para desarrolladores de AWS X-Ray.
Secciones
• Seguimiento en las aplicaciones de ejemplo (p. 413)

Lambda

function».

publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...
412

Resources:
function:
Properties:
Tracing: Active
...

de Lambda (p. 76).

SDK para Java de SDK para Java y X-Ray.
Resources:
function:
Properties:
CodeUri: build/distributions/blank-java.zip
Tracing: Active
Layers:
- !Ref libs
...
libs:
Properties:
LayerName: blank-java-lib
Description: Dependencies for the blank-java sample app.
ContentUri: build/blank-java-lib.zip
CompatibleRuntimes:
- java8
de implementación.
Para crear una capa de dependencias, es necesario realizar cambios en la configuración de compilación
para generar el archivo de capas antes de la implementación. Para ver un ejemplo práctico, consulte la
aplicación de muestra java-basic.
Seguimiento en las aplicaciones de ejemplo

El repositorio de GitHub para esta guía contiene aplicaciones de ejemplo en las que se muestra el uso del
seguimiento. Cada una de las aplicaciones de ejemplo contiene scripts para facilitar la implementación y la
limpieza, una plantilla de AWS SAM y recursos de soporte.
413
Tutorial: IDE de Eclipse
Todas las aplicaciones de ejemplo tienen activado el seguimiento activo de las funciones Lambda. En la
aplicación blank-java, se muestra la instrumentación automática de los clientes de AWS SDK para Java
2.x, la administración de segmentos para pruebas, subsegmentos personalizados y el uso de capas de
Lambda para almacenar dependencias en tiempo de ejecución.
En este ejemplo de la aplicación blank-java, se muestran los nodos del servicio Lambda, una función
y la API de Lambda. La función llama a la API de Lambda para monitorear el uso del almacenamiento en
Lambda.
Creación de un paquete de implementación con

Eclipse
Esta sección muestra cómo empaquetar el código Java en un paquete de implementación utilizando el IDE
de Eclipse y el complemento Maven para Eclipse.
Note
El conjunto de herramientas de Eclipse para el SDK de AWS ofrece un complemento de Eclipse

que permite crear un paquete de implementación y cargarlo para crear una función de Lambda.
Si utiliza el IDE de Eclipse como entorno de desarrollo, este complemento le permite crear código
Java, crear y cargar un paquete de implementación y crear una función de Lambda. Para obtener
más información, consulte Guía de introducción a AWS Toolkit for Eclipse. Para ver un ejemplo de
cómo utilizar el kit de herramientas para crear funciones de Lambda, consulte Uso de Lambda con
AWS Toolkit para Eclipse.
Temas
• Creación y compilación de un proyecto (p. 415)
414
Requisitos previos
Requisitos previos
Instale el complemento Maven para Eclipse.
1. Inicie Eclipse. En el menú Help de Eclipse, elija Install New Software.

2. En la ventana Install (Instalar), escriba http://download.eclipse.org/technology/m2e/
releases en el cuadro Work with: (Funciona con) y elija Add (Añadir).
3. Siga los pasos para completar la configuración.
Creación y compilación de un proyecto

En este paso, iniciará Eclipse y creará un proyecto de Maven. Añadirá las dependencias necesarias y
creará el proyecto. La compilación producirá un archivo .jar, que es el paquete de implementación.
1. Cree un nuevo proyecto de Maven en Eclipse.
a. En el menú File, elija New, seguido de Project.

b. En la ventana New Project, elija Maven Project.
c. En la ventana New Maven Project, elija Create a simple project y deje el resto de selecciones con
sus valores predeterminados.
d. En las ventanas New Maven Project y Configure project, escriba la siguiente información para
Artifact:
• Group Id: doc-examples

• Artifact Id: lambda-java-example
• Version: 0.0.1-SNAPSHOT
• Packaging: jar
• Name: lambda-java-example
2. Añada la dependencia aws-lambda-java-core al archivo pom.xml.
Proporciona definiciones de las interfaces RequestHandler, RequestStreamHandler y Context.

Esto le permite compilar código que puede utilizar con AWS Lambda.
a. Abra el menú contextual (haga clic con el botón derecho) del archivo pom.xml, elija Maven y, a
continuación, Add Dependency.
b. En las ventanas Add Dependency, escriba los siguientes valores:
Group Id: com.amazonaws
Artifact Id: aws-lambda-java-core
Versión: 1.2.1
Note
Si está siguiendo otros temas del tutorial de esta guía, es posible que los tutoriales
específicos le soliciten añadir más dependencias. Asegúrese de añadir las dependencias
que sean necesarias.
3. Añada la clase de Java al proyecto.
a. Abra el menú contextual (haga clic con el botón derecho) del subdirectorio src/main/java del
proyecto, elija New y, a continuación, Class.
b. En la ventana New Java Class, escriba los siguientes valores:
415
Creación y compilación de un proyecto
• Package (Paquete): example

• Name (Nombre): Hello
Note
Si está siguiendo otros temas del tutorial de esta guía, es posible que los tutoriales
específicos le recomienden un nombre de paquete o de clase diferente.
c. Añada el código Java. Si está siguiendo otros temas del tutorial de esta guía, añada el código
proporcionado.
4. Compile el proyecto.
Abra el menú contextual (haga clic con el botón derecho) del proyecto en Package Explorer y elija
Run As, seguido de Maven Build.... En la ventana Edit Configuration (Editar configuración), escriba
package en el cuadro Goals (Objetivos).
Note
El archivo .jar resultante, lambda-java-example-0.0.1-SNAPSHOT.jar, no es

el archivo .jar independiente final que puede utilizar en el paquete de implementación.
En el siguiente paso, añadirá el maven-shade-plugin de Apache para crear el .jar.
independiente. Para obtener más información, vaya a Apache Maven Shade Plugin.
5. Añada el complemento maven-shade-plugin y vuelva a compilar.
El complemento maven-shade-plugin tomará los artefactos (archivos .jar) producidos por el objetivo
package (produce archivos .jar de código de cliente), y creará un archivo .jar independiente que
contiene el código de cliente compilado, así como las dependencias resueltas de pom.xml.
a. Abra el menú contextual (haga clic con el botón derecho) del archivo pom.xml, elija Maven y, a
continuación, Add Plugin.
b. En la ventana Add Plugin, escriba los siguientes valores:
• Group Id: org.apache.maven.plugins

• Artifact Id: maven-shade-plugin
• Versión: 3.2.2
c. Vuelva a compilar de nuevo.
Esta vez crearemos el archivo .jar como antes y, a continuación, utilizaremos el complemento
maven-shade-plugin para extraer las dependencias y crear el .jar independiente
i. Abra el menú contextual (haga clic con el botón derecho) del proyecto, elija Run As y, a
continuación Maven build....
ii. En las ventanas Edit Configuration (Editar configuración), escriba package shade:shade
en el cuadro Goals (Objetivos).
iii. Elija Run.
Puede encontrar el archivo .jar independiente resultante (es decir, el paquete de

implementación), en el subdirectorio /target .
Abra el menú contextual (haga clic con el botón derecho) del subdirectorio /target
y elija Show In, seguido de System Explorer; encontrará el archivo lambda-java-
example-0.0.1-SNAPSHOT.jar.
416

con Go
En las secciones siguientes se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en Go.
Tiempos de ejecución de Go
Go 1.x go1.x Amazon Linux
AWS Lambda proporciona las siguientes bibliotecas para Go:
• github.com/aws/aws-lambda-go/lambda: la implementación del modelo de programación de Lambda

para Go. AWS Lambda utiliza este paquete para invocar su controlador (p. 419).
• github.com/aws/aws-lambda-go/lambdacontext: Elementos auxiliares para obtener acceso a la
información del objeto del contexto (p. 422).
• github.com/aws/aws-lambda-go/events: esta biblioteca proporciona definiciones de tipos para las
integraciones de orígenes de eventos comunes.
Note
Aplicaciones de Lambda de ejemplo en Go
• blank-go: una función de Go que muestra el uso de las bibliotecas de Go de Lambda, el

registro, las variables de entorno y el SDK de AWS.
Temas
• Controlador de funciones de AWS Lambda en Go (p. 419)
• Objeto context AWS Lambda en Go (p. 422)
• Registro de funciones de AWS Lambda en Go (p. 424)
• Instrumentación del código Go en AWS Lambda (p. 427)
• Uso de variables de entorno (p. 431)

Go
Para crear una función de Lambda, primero debe crear un paquete de implementación de la función de
Lambda, que es un archivo .zip que contiene el código (un ejecutable Go) y las dependencias.
417
Creación de un paquete de implementación en Windows
Después de crear un paquete de implementación, puede cargarlo directamente o cargar primero el

archivo .zip en un bucket de Amazon S3 de la misma región de AWS en la que desea crear la función de
Lambda y, a continuación, especificar el nombre del bucket y el nombre de la clave de objeto cuando crea
la función de Lambda mediante la consola o la CLI de AWS.
Descargue la biblioteca de Lambda para Go con go get y compile el ejecutable.
~/my-function$ go get github.com/aws/aws-lambda-go/lambda

~/my-function$ GOOS=linux go build main.go
Establecer GOOS en linux garantiza que el ejecutable compilado es compatible con el tiempo de
ejecución de Go (p. 130), incluso si lo compila en un entorno que no sea Linux.
Cree un paquete de implementación empaquetando el archivo ejecutable en un archivo ZIP y utilice la

AWS CLI para crear una función. El parámetro del controlador debe coincidir con el nombre del archivo
ejecutable que contenga su controlador.
~/my-function$ zip function.zip main

~/my-function$ aws lambda create-function --function-name my-function --runtime go1.x \
--zip-file fileb://function.zip --handler main \
--role arn:aws:iam::123456789012:role/execution_role
Creación de un paquete de implementación en

Windows
Para crear un archivo .zip que funcione en AWS Lambda con Windows, se recomienda instalar la
herramienta build-lambda-zip.
Note
Si aún no lo ha hecho, deberá instalar git y, después, añadir el ejecutable git a la variable de
entorno de Windows %PATH%.
Ejecute el comando siguiente para descargar la herramienta:
go.exe get -u github.com/aws/aws-lambda-go/cmd/build-lambda-zip
Utilice la herramienta desde su GOPATH. Si tiene una instalación predeterminada de Go, la herramienta
suele estar en %USERPROFILE%\Go\bin. De lo contrario, vaya hasta la ubicación donde instaló el entorno
en tiempo de ejecución de Go y haga lo siguiente:
En cmd.exe, ejecute lo siguiente:
set GOOS=linux
go build -o main main.go
%USERPROFILE%\Go\bin\build-lambda-zip.exe -output main.zip main
En Powershell, ejecute lo siguiente:
$env:GOOS = "linux"
$env:CGO_ENABLED = "0"
$env:GOARCH = "amd64"
go build -o main main.go
~\Go\Bin\build-lambda-zip.exe -output main.zip main
418
Controlador
Controlador de funciones de AWS Lambda en Go

Una función de Lambda escrita en Go se crea como ejecutable de Go. En el código de la función de
Lambda, debe incluir el paquete github.com/aws/aws-lambda-go/lambda, que implementa el modelo de
programación de Lambda para Go. Además, debe implementar el código de la función de controlador y
una función main().
package main
import (
"fmt"
"context"
)
type MyEvent struct {

Name string `json:"name"`
}
func HandleRequest(ctx context.Context, name MyEvent) (string, error) {

return fmt.Sprintf("Hello %s!", name.Name ), nil
}
func main() {
lambda.Start(HandleRequest)
}
Tenga en cuenta lo siguiente:
• package main: en Go, el paquete que contiene func main() debe denominarse siempre main.
• import: utilice esta opción para incluir las bibliotecas que requiere la función de Lambda. En este
ejemplo, incluye:
• context: Objeto context AWS Lambda en Go (p. 422).
• fmt: objeto de formato de Go que se utiliza para dar formato al valor de retorno de la función.
• github.com/aws/aws-lambda-go/lambda: como se mencionó anteriormente, implementa el modelo de
programación de Lambda para Go.
• func HandleRequest(ctx context.Context, name MyEvent) (string, error): esta es la signatura del
controlador de Lambda e incluye el código que se va a ejecutar. Además, los parámetros incluidos
indican lo siguiente:
• ctx context.Context: proporciona información en tiempo de ejecución para la invocación de la función
de Lambda. ctx es la variable que declara para aprovechar la información disponible a través de
Objeto context AWS Lambda en Go (p. 422).
• name MyEvent: tipo de entrada con un nombre de variable de name cuyo valor se devuelve en la
instrucción return.
• string, error: devuelve dos valores: cadena en caso de ejecución correcta e información de error
estándar. Para obtener más información sobre el control de errores personalizado, consulte Errores de
funciones de AWS Lambda en Go (p. 427).
• return fmt.Sprintf("Hello %s!", name), nil: devuelve simplemente un saludo "Hello" formateado con
el nombre que ha proporcionado en el eevnto de entrada. nil indica que no hubo errores y que la
función se ejecutó correctamente.
• func main(): el punto de entrada que ejecuta el código de la función de Lambda. Esto es necesario.
Al añadir lambda.Start(HandleRequest) entre los corchetes del código func main(){}, la

función de Lambda se ejecuta. De acuerdo con los estándares del lenguaje Go, el corchete de apertura
{ debe colocarse directamente al final de la firma de función main.
419
Controlador de funciones de
Lambda con tipos estructurados
Controlador de funciones de Lambda con tipos

estructurados
En el ejemplo anterior, el tipo de entrada era una cadena sencilla. Sin embargo, también pueden pasarse
eventos estructurados al controlador de funciones:
package main
import (
"fmt"
)
type MyEvent struct {

Name string `json:"What is your name?"`
Age int `json:"How old are you?"`
}
type MyResponse struct {

Message string `json:"Answer:"`
}
func HandleLambdaEvent(event MyEvent) (MyResponse, error) {

return MyResponse{Message: fmt.Sprintf("%s is %d years old!", event.Name,
event.Age)}, nil
}
func main() {
lambda.Start(HandleLambdaEvent)
}
La solicitud sería similar a la siguiente:
# request
{
"What is your name?": "Jim",
"How old are you?": 33
}
Y la respuesta sería similar a:
# response
{
"Answer": "Jim is 33 years old!"
}
Para que se exporten, los nombres de campo en la estructura de eventos deben estar en mayúsculas.
Para obtener más información acerca de cómo controlar eventos de orígenes de eventos AWS, consulte
aws-lambda-go/events.
Signaturas del controlador válidas

Al crear un controlador de funciones de Lambda en Go tiene varias opciones, pero debe cumplir las reglas
siguientes:
• El controlador debe ser una función.
420
Uso del estado global
• El controlador puede aceptar entre 0 y 2 argumentos. Si hay dos argumentos, el primero debe
implementar context.Context.
• El controlador puede devolver entre 0 y 2 argumentos. Si hay un único valor de retorno, este debe
implementar error. Si hay dos valores de retorno, el segundo debe implementar error. Para obtener
más información acerca de cómo implementar la información de control de errores, consulte Errores de
funciones de AWS Lambda en Go (p. 427).
A continuación se enumeran las signaturas del controlador válidas. TIn y TOut representan los tipos
compatibles con la biblioteca estándar encoding/json. Para obtener más información, consulte func
Unmarshal a fin de saber cómo se deserializan estos tipos.
•
func ()
•
func () error
•
func (TIn), error
•
func () (TOut, error)
•
func (context.Context) error
•
func (context.Context, TIn) error
•
func (context.Context) (TOut, error)
•
func (context.Context, TIn) (TOut, error)
Uso del estado global

Es posible declarar y modificar variables globales que son independientes del código de controlador de la
función de Lambda. Además, el controlador puede declarar una función init que se ejecute cuando este
se carga. El comportamiento es el mismo en AWS Lambda que en los programas Go estándar. Una sola
instancia de su función de Lambda nunca controlará varios eventos de forma simultánea.
package main
import (
"log"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/s3"
"github.com/aws/aws-sdk-go/aws"
)
var invokeCount = 0
var myObjects []*s3.Object
func init() {
svc := s3.New(session.New())
input := &s3.ListObjectsV2Input{
Bucket: aws.String("examplebucket"),
}
result, _ := svc.ListObjectsV2(input)
myObjects = result.Contents
421
Contexto
func LambdaHandler() (int, error) {

invokeCount = invokeCount + 1
log.Print(myObjects)
return invokeCount, nil
}
func main() {
lambda.Start(LambdaHandler)
}
Objeto context AWS Lambda en Go

proporciona métodos y propiedades con información acerca de la invocación, la función y el entorno de
ejecución.
La biblioteca de contexto de Lambda proporciona las siguientes variables globales, métodos y

propiedades.
Variables globales
• FunctionName: El nombre de la función de Lambda.

• FunctionVersion: La versión (p. 70) de la función.
• MemoryLimitInMB: La cantidad de memoria que se asigna para la función.
• LogGroupName: El grupo de registros de la función.
• LogStreamName: El flujo de registro para la instancia de la función.
Métodos de context
• Deadline: Devuelve la fecha en la que la ejecución agota su tiempo de espera en milisegundos de

tiempo Unix.
• InvokedFunctionArn: El nombre de recurso de Amazon (ARN) que se utiliza para invocar la función.
• AwsRequestID: El identificador de la solicitud de invocación.
• Identity: (aplicaciones móviles) Información acerca de la identidad de Amazon Cognito que ha
• ClientContext: (aplicaciones móviles) El contexto del cliente proporcionado a Lambda por parte de la
Acceso a la información del contexto de invocación

Las funciones de Lambda tienen acceso a metadatos acerca de su entorno y la solicitud de invocación.
Se puede obtener acceso en el contexto del paquete. Si el controlador incluye context.Context como
parámetro, Lambda insertará información acerca de su función en la propiedad Value del contexto. Tenga
en cuenta que debe importar la biblioteca lambdacontext para obtener acceso al contenido del objeto
context.Context.
422
Acceso a la información del contexto de invocación
package main
import (
"context"
"log"
"github.com/aws/aws-lambda-go/lambdacontext"
)
func CognitoHandler(ctx context.Context) {

lc, _ := lambdacontext.FromContext(ctx)
log.Print(lc.Identity.CognitoIdentityPoolID)
}
func main() {
lambda.Start(CognitoHandler)
}
En el ejemplo anterior, lc es la variable que se usa para consumir la información que el objeto context
capturó y log.Print(lc.Identity.CognitoIdentityPoolID) imprime dicha información, en este
caso, CognitoIdentityPoolID.
En el ejemplo siguiente se indica cómo utilizar el objeto context para monitorizar el tiempo que tarda en
ejecutarse la función de Lambda. Esto le permite analizar las expectativas de desempeño y ajustar el
código de su función en consecuencia, si es necesario.
package main
import (
"context"
"log"
"time"
)
func LongRunningHandler(ctx context.Context) (string, error) {
deadline, _ := ctx.Deadline()
deadline = deadline.Add(-100 * time.Millisecond)
timeoutChannel := time.After(time.Until(deadline))
for {
select {
case <- timeoutChannel:

return "Finished before timing out.", nil
default:
log.Print("hello!")
time.Sleep(50 * time.Millisecond)
}
}
}
func main() {
lambda.Start(LongRunningHandler)
}
423
Registro
Registro de funciones de AWS Lambda en Go

Para generar registros desde el código de la función, puede utilizar los métodos del paquete fmt o
cualquier biblioteca de registro que escriba en stdout o en stderr. En el ejemplo siguiente, se utiliza el
paquete de registro.
Example main.go – registro
func handleRequest(ctx context.Context, event events.SQSEvent) (string, error) {

// event
eventJson, _ := json.MarshalIndent(event, "", " ")
log.Printf("EVENT: %s", eventJson)
// environment variables
log.Printf("REGION: %s", os.Getenv("AWS_REGION"))
log.Println("ALL ENV VARS:")
for _, element := range os.Environ() {
log.Println(element)
}
START RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Version: $LATEST

2020/03/27 03:40:05 EVENT: {
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"md5OfBody": "7b27xmplb47ff90a553787216d55d91d",
"md5OfMessageAttributes": "",
"attributes": {
"ApproximateFirstReceiveTimestamp": "1523232000001",
"SenderId": "123456789012",
"SentTimestamp": "1523232000000"
},
...
2020/03/27 03:40:05 AWS_LAMBDA_LOG_STREAM_NAME=2020/03/27/
[$LATEST]569cxmplc3c34c7489e6a97ad08b4419
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_NAME=blank-go-function-9DV3XMPL6XBC
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_MEMORY_SIZE=128
2020/03/27 03:40:05 AWS_LAMBDA_FUNCTION_VERSION=$LATEST
2020/03/27 03:40:05 AWS_EXECUTION_ENV=AWS_Lambda_go1.x
END RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71
REPORT RequestId: dbda340c-xmpl-4031-8810-11bb609b4c71 Duration: 38.66 ms Billed Duration:
XRAY TraceId: 1-5e7d7595-212fxmpl9ee07c4884191322 SegmentId: 42ffxmpl0645f474 Sampled: true
El tiempo de ejecución de Go registra las líneas START, END y REPORT de cada invocación. La línea del

evento.
424

comandos.
Secciones

CloudWatch Logs.

Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}
425
Mediante AWS CLI

#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
426
},
{
"timestamp": 1559763003218,
}
],
}
Errores de funciones de AWS Lambda en Go

Puede crear un control de errores personalizado para generar una excepción directamente desde la
función de Lambda y controlarla directamente.
En los siguientes códigos de muestra se ilustra cómo hacerlo. Tenga en cuenta que los errores
personalizados en Go deben importar el módulo errors.
package main
import (
"errors"
)
func OnlyErrors() error {

return errors.New("something went wrong!")
}
func main() {
lambda.Start(OnlyErrors)
}
Que devuelve lo siguiente:
{
"errorMessage": "something went wrong!",
"errorType": "errorString"
}
Instrumentación del código Go en AWS Lambda

427
Tracing


Precios
428
Tracing
Para registrar detalles sobre las llamadas que el controlador realiza a otros recursos y servicios, utilice el
SDK de X-Ray para Go. Descargue el SDK desde su repositorio de GitHub con go get:
$ go get github.com/aws/aws-xray-sdk-go
Para instrumentar clientes SDK de AWS, pase el cliente al método xray.AWS().
xray.AWS(s3.Client)

con anotaciones y metadatos. Para obtener más información, consulte SDK de X-Ray para Go en la Guía
429
Secciones

Lambda

function».

publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...

Resources:
function:
Properties:
Tracing: Active
...
430
Uso de variables de entorno

Para acceder a las variables de entorno (p. 56) en Go, utilice la función Getenv .
El siguiente ejemplo explica cómo hacerlo. Tenga en cuenta que la función importa el paquete fmt para
formatear los resultados impresos y el paquete os, una interfaz del sistema independiente de la plataforma
que le permite obtener acceso a las variables de entorno.
package main
import (
"fmt"
"os"
)
func main() {
fmt.Printf("%s is %s. years old\n", os.Getenv("NAME"), os.Getenv("AGE"))
Para obtener una lista de variables de entorno establecidas por el motor de ejecución de Lambda, consulte
Variables de entorno de tiempo de ejecución (p. 58).
431
Creación de funciones Lambda con

C#
En las siguientes secciones se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en C#.
AWS Lambda proporciona las siguientes bibliotecas de funciones de C#:
• Amazon.Lambda.Core: esta biblioteca proporciona un registrador de Lambda estático, interfaces

serialización y un objeto context. El objeto Context (Objeto context de AWS Lambda en C# (p. 443))
proporciona información del tiempo de ejecución acerca de la función de Lambda.
• Amazon.Lambda.Serialization.Json: es una implementación de la interfaz de serialización de
Amazon.Lambda.Core.
• Amazon.Lambda.Logging.AspNetCore: proporciona una biblioteca para el registro desde ASP.NET.
• Objetos de evento (POCOs) para varios servicios de AWS, entre los que se incluyen:
• Amazon.Lambda.APIGatewayEvents
• Amazon.Lambda.CognitoEvents
• Amazon.Lambda.ConfigEvents
• Amazon.Lambda.DynamoDBEvents
• Amazon.Lambda.KinesisEvents
• Amazon.Lambda.S3Events
• Amazon.Lambda.SQSEvents
• Amazon.Lambda.SNSEvents
Estos paquetes están disponibles en Nuget Packages.
Runtimes de .NET
Note
Aplicaciones de Lambda de muestra en C#
• blank-csharp: una función de C# que muestra el uso de las bibliotecas de .NET de Lambda, el
registro, las variables de entorno, el seguimiento de AWS X-Ray, las pruebas de unidad y el
SDK de AWS.
• ec2-spot: una función que administra las solicitudes de instancia de spot en Amazon EC2.
Temas
432
• Controlador de funciones de AWS Lambda en C# (p. 438)

• Objeto context de AWS Lambda en C# (p. 443)
• Registro de funciones de AWS Lambda en C# (p. 444)
• Instrumentación de código C# en AWS Lambda (p. 450)
AWS Lambda Paquete de implementación en C#

Un paquete de implementación de Lambda para .NET Core es un archivo zip del ensamblado compilado
de su función con todas sus dependencias de ensamblado. El paquete también contiene un archivo
proj.deps.json. Este indica al entorno en tiempo de ejecución de .NET Core todas las dependencias
de su función y un archivo proj.runtimeconfig.json, que se usa para configurar dicho entorno.
El comando publish de la CLI de .NET puede crear una carpeta con todos estos archivos, pero
proj.runtimeconfig.json no se incluirá de forma predeterminada, porque un proyecto de Lambda
suele configurarse para ser una biblioteca de clases. Para forzar que proj.runtimeconfig.json
se escriba como parte del proceso de publish, pase el argumento de la línea de comandos: /
p:GenerateRuntimeConfigurationFiles=true to the publish command.
Aunque el paquete de implementación se puede crear con el comando dotnet publish, se

recomienda crearlo con AWS Toolkit for Visual Studio (p. 436) o CLI de .NET Core (p. 433). Estas
son herramientas optimizadas específicamente para Lambda a fin de garantizar que el archivo lambda-
project.runtimeconfig.json existe y sirve para optimizar el paquete, incluyendo la eliminación de
dependencias no basadas en Linux.
Temas
• CLI de .NET Core (p. 433)
• AWS Toolkit for Visual Studio (p. 436)
CLI de .NET Core

La CLI de .NET Core ofrece una manera multiplataforma de crear aplicaciones de Lambda basadas
en .NET. En esta sección se presupone que ha instalado la CLI de .NET Core. Si todavía no lo ha hecho,
hágalo aquí.
En la CLI de .NET se usa el comando new para crear proyectos .NET desde una línea de comando. Esto
resulta útil si desea crear un proyecto fuera de Visual Studio. Para ver una lista de los tipos de proyectos
disponibles, abra una línea de comando, vaya hasta la ubicación donde instaló el entorno en tiempo de
ejecución de .NET Core y ejecute el siguiente comando:
dotnet new -all

Usage: new [options]
...
Templates Short Name Language Tags
-------------------------------------------------------------------------------------------------------
Console Application console [C#], F#, VB
Common/Console
Class library classlib [C#], F#, VB
Common/Library
Unit Test Project mstest [C#], F#, VB
Test/MSTest
xUnit Test Project xunit [C#], F#, VB
Test/xUnit
...
Examples:
433
CLI de .NET Core
dotnet new mvc --auth Individual

dotnet new viewstart
dotnet new --help
AWS Lambda ofrece plantillas adicionales a través del paquete NuGet Amazon.Lambda.Templates. Para
instalar este paquete, ejecute el comando siguiente:
dotnet new -i Amazon.Lambda.Templates
Una vez completada la instalación, las plantillas de Lambda; aparecen como parte de dotnet new. Para
examinar los detalles acerca de una plantilla, utilice la opción de ayuda.
dotnet new lambda.EmptyFunction --help
La plantilla lambda.EmptyFunction es compatible con las siguientes opciones.
• --name: nombre de la función.

• --profile: el nombre de un perfil en su archivo de credenciales de AWS SDK para .NET.
• --region: la región de AWS en la que crear la función.
Estas opciones se guardan en un archivo denominado aws-lambda-tools-defaults.json.
Cree un proyecto de función con la plantilla lambda.EmptyFunction.
dotnet new lambda.EmptyFunction --name MyFunction
En el directorio src/myfunction, examine los archivos siguientes:
• aws-lambda-tools-defaults.json: aquí se especifican las opciones de línea de comando al implementar su

función de Lambda. Por ejemplo:
"profile" : "default",
"region" : "us-east-2",
"configuration" : "Release",
"framework" : "netcoreapp2.1",
"function-runtime":"dotnetcore3.1",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "MyFunction::MyFunction.Function::FunctionHandler"
• Function.cs: el código de la función de controlador de Lambda. Es una plantilla de C# que incluye la

biblioteca Amazon.Lambda.Core predeterminada y un atributo LambdaSerializer predeterminado.
Para obtener más información acerca de las opciones y los requisitos de serialización, consulte
Serialización de las funciones de Lambda (p. 441). También incluye una función de muestra que puede
editar para aplicar el código de su función de Lambda.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
// Assembly attribute to enable the Lambda function's JSON input to be converted into
a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
434
CLI de .NET Core
namespace MyFunction
{
public class Function
{
public string FunctionHandler1(string input, ILambdaContext context)

{
return input?.ToUpper();
}
}
}
• MyFunction.csproj: archivo MSBuild que enumera los archivos y ensamblados que componen la
aplicación.
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netcoreapp2.1</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Amazon.Lambda.Core" Version="1.0.0 " />
<PackageReference Include="Amazon.Lambda.Serialization.Json" Version="1.3.0" />
</ItemGroup>
</Project>
• Readme: use este archivo para documentar su función de Lambda.
En el myfunction/test directory, examine the following files:
• myFunction.Tests.csproj: como se ha indicado anteriormente, este es un archivo MSBuild que enumera

los archivos y los ensamblados que componen su proyecto de prueba. Tenga en cuenta que también
incluye la biblioteca Amazon.Lambda.Core, lo que le permite integrar a la perfección cualquier plantilla
de Lambda necesaria para probar la función.
...
<PackageReference Include="Amazon.Lambda.Core" Version="1.0.0 " />

...
• FunctionTest.cs: el mismo archivo de plantilla de código C# que se incluye en el directorio src. Edite
este archivo para reflejar el código de producción de su función y probarlo antes de cargar su función de
Lambda en un entorno de producción.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
using Amazon.Lambda.TestUtilities;
using MyFunction;
namespace MyFunction.Tests
{
public class FunctionTest
{
435
AWS Toolkit for Visual Studio
[Fact]
public void TestToUpperFunction()
{
// Invoke the lambda function and confirm the string was upper cased.
var function = new Function();
var context = new TestLambdaContext();
var upperCase = function.FunctionHandler("hello world", context);
Assert.Equal("HELLO WORLD", upperCase);

}
}
}
Una vez que la función ha superado las pruebas, puede crearla e implementarla mediante la herramienta
de .NET Core Global Amazon.Lambda.Tools. Para instalar la herramienta de .NET Core Global, ejecute el
siguiente comando.
dotnet tool install -g Amazon.Lambda.Tools
Si ya tiene la herramienta instalada, puede asegurarse de estar utilizando la última versión con el siguiente
comando.
dotnet tool update -g Amazon.Lambda.Tools
Para obtener más información acerca de la herramienta de .NET Core Global Amazon.Lambda.Tools,
consulte su repositorio GitHub.
Con las herramientas Amazon.Lambda.Tools instalados, puede implementar su función con el siguiente
comando:
dotnet lambda deploy-function MyFunction --function-role role
Después de la implementación, puede volver a probarla en un entorno de producción con el comando

siguiente y pasar un valor distinto al controlador de la función de Lambda:
dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"
Si todos los aspectos del proceso son correctos, debe ver lo siguiente:
dotnet lambda invoke-function MyFunction --payload "Just Checking If Everything is OK"

Payload:
"JUST CHECKING IF EVERYTHING IS OK"
Log Tail:
START RequestId: id Version: $LATEST
END RequestId: id
REPORT RequestId: id Duration: 0.99 ms Billed Duration: 100 ms Memory Size:
256 MB Max Memory Used: 12 MB

Puede crear aplicaciones de Lambda basadas en .NET mediante el complemento de Lambda para AWS
Toolkit for Visual Studio. El conjunto de herramientas está disponible como unaextensión de Visual Studio.
1. Lance Microsoft Visual Studio y elija New project.
436
a. En el menú File, elija New, seguido de Project.

b. En la ventana New Project, elija AWS Lambda Project (.NET Core), seguido de OK.
c. En la ventana Select Blueprint, dispondrá de una serie de aplicaciones de ejemplo con código de
muestra para comenzar a crear una aplicación de Lambda basada en .NET.
d. Para crear una aplicación de Lambda desde cero, elija Empty Function (Función vacía), seguido
de Finish (Finalizar).
2. Examine el archivo aws-lambda-tools-defaults.json, que se crea como parte del proyecto.
Puede configurar las opciones de este archivo, que las herramientas de Lambda leerán de forma
predeterminada. Las plantillas de proyecto creadas en Visual Studio definen muchos de estos campos
con valores predeterminados. Observe los campos siguientes:
• profile: el nombre de un perfil en el archivo de credenciales de AWS SDK para .NET.

• function-handler: aquí es donde se especifica el valor de function handler y por esa razón no
se tiene que definir en el asistente. Sin embargo, siempre que cambie el nombre de Assembly,
Namespace, Class o Function en el código de su función, tendrá que actualizar los campos
correspondientes en aws-lambda-tools-defaults.json file.
{
"profile":"default",
"region" : "us-east-2",
"configuration" : "Release",
"framework" : "netcoreapp2.1",
"function-runtime":"dotnetcore3.1",
"function-memory-size" : 256,
"function-timeout" : 30,
"function-handler" : "Assembly::Namespace.Class::Function"
}
3. Abra el archivo Function.cs. Se le proporcionará una plantilla para implementar el código del
controlador de la función de Lambda.
4. Una vez que haya escrito el código que representa la función de Lambda, puede cargarlo haciendo
clic con el botón derecho del ratón en el nodo Project (Previsión) de la aplicación y, a continuación,
eligiendo Publish to AWS Lambda (Publicar en AWS Lambda).
5. En la ventana Upload Lambda Function (Cargar función de Lambda), escriba un nombre para la
función o seleccione una función que ya se haya publicado para volver a publicarla. A continuación,
elija Siguiente
6. En la ventana Advanced Function Details (Detalles de función avanzada), configure las siguientes
opciones:
437
Controlador
• Role Name (Nombre de rol) (obligatorio): El rol de IAM (p. 33) que AWS Lambda asume cuando
ejecuta la función.
• Environment (Entorno): Pares clave-valor que Lambda establece en el entorno de ejecución. Utilice
variables de entorno (p. 56) para ampliar la configuración de la función fuera del código.
• Memory (Memoria): La cantidad de memoria disponible para la función durante la ejecución. Elija
una cantidad entre 128 MB y 3,008 MB (p. 31), en incrementos de 64 MB.
• Timeout (Tiempo de espera): La cantidad de tiempo que Lambda permite que una función se
ejecute antes de detenerla. El valor predeterminado es de 3 segundos. El valor máximo permitido es
de 900 segundos.
• VPC: Si la función necesita acceso de red a recursos que no están disponibles a través de Internet,
configúrela para que se conecte a una VPC (p. 81).
• DLQ: Si la función se invoca de forma asíncrona, elija una cola o un tema (p. 107) para recibir las
invocaciones erróneas.
• Enable active tracing (Habilitar rastreo activo): Realice un muestreo de las solicitudes entrantes y
rastree las solicitudes muestreadas con AWS X-Ray (p. 311).
7. Elija Next seguido de Upload para implementar la aplicación.
Para obtener más información, consulte Implementación de un proyecto de AWS Lambda con la CLI
de .NET Core.
Controlador de funciones de AWS Lambda en C#

Cuando cree una función de Lambda debe especificar un controlador que AWS Lambda puede invocar
cuando el servicio ejecute la función en su nombre.
Un controlador de función de Lambda se define como una instancia o un método estático en una clase. Si
desea acceder al objeto context de Lambda, está disponible definiendo un parámetro de método de tipo
ILambdaContext, una interfaz que puede utilizar para obtener acceso a información acerca de la ejecución
actual, como el nombre de la función actual, la cantidad máxima de memoria, el tiempo que falta para
finalizar la ejecución y el registro.
returnType handler-name(inputType input, ILambdaContext context) {

...
}
En la sintaxis, tenga en cuenta lo siguiente:
• inputType: el primer parámetro del controlador es su entrada, que puede estar formada por datos de
eventos (publicados por un origen de eventos) o por una entrada personalizada proporcionada por el
usuario, como una cadena o cualquier objeto de datos personalizado.
• returnType: si piensa invocar la función de Lambda de forma síncrona (utilizando el tipo de invocación
RequestResponse), puede devolver la salida de la función utilizando cualquiera de los tipos de datos
admitidos. Por ejemplo, si utiliza una función de Lambda como backend de aplicaciones móviles, la
invocación se realiza de forma síncrona. El tipo de datos de salida se serializará en JSON.
Si piensa invocar la función de Lambda de forma asíncrona (utilizando el tipo de invocación Event),
returnType debería ser void. Por ejemplo, si utiliza AWS Lambda con orígenes de eventos como
Amazon S3 o Amazon SNS, estos orígenes de eventos invocan la función de Lambda mediante el tipo
de invocación Event.
• ILambdaContext context: el segundo argumento de la firma del controlador es opcional.
Proporciona acceso al objeto context (p. 443) que tiene información sobre la función y la solicitud.
438
Control de flujos
Control de flujos
De forma predeterminada, solo se admite el tipo System.IO.Stream como parámetro de entrada.
Por ejemplo, fíjese en el siguiente código de ejemplo de C#.
using System.IO;
namespace Example
{
public class Hello
{
public Stream MyHandler(Stream stream)
{
//function logic
}
}
}
En el código C# del ejemplo, el primer parámetro del controlador es la entrada al controlador (MyHandler),
que puede estar formada por datos de eventos (publicados por un origen de eventos como Amazon S3)
o por una entrada personalizada proporcionada por el usuario, tal como Stream (como sucede en este
ejemplo) o cualquier objeto de datos personalizado. La salida es de tipo Stream.
Control de tipos de datos estándar

Para todos los demás tipos, que se indican a continuación, tendrá que especificar un serializador.
• Tipos primitivos de .NET (como string o int).

• Colecciones y mapas: IList, IEnumerable, IList<T>, Array, IDictionary, IDictionary<TKey, TValue>
• Tipos POCO (objetos CLR estándar simples, o Plain old CLR objects)
• Tipos de eventos predefinidos de AWS
• Para las invocaciones asíncronas, Lambda ignorará el tipo de retorno. El tipo de retorno se puede
establecer en void en estos casos.
• Si está utilizando la programación asíncrona de .NET, el tipo de retorno puede ser Task y Task<T>, y
utilizar las palabras clave async y await. Para obtener más información, consulte Uso de async en
funciones C# con AWS Lambda (p. 442).
A menos que los parámetros de entrada y salida de la función sean del tipo System.IO.Stream,
deberá serializarlos. AWS Lambda proporciona un serializador predeterminado que se puede aplicar
en el nivel de ensamblado o de método de la aplicación, o puede definir uno implementando la interfaz
ILambdaSerializer proporcionada por la biblioteca Amazon.Lambda.Core. Para obtener más
información, consulte AWS Lambda Paquete de implementación en C# (p. 433).
Para añadir el atributo serializador predeterminado a un método, primero añada una dependencia de
Amazon.Lambda.Serialization.Json en el archivo project.json.
{
"version": "1.0.0-*",
"dependencies":{
"Microsoft.NETCore.App": {
"type": "platform",
"version": "1.0.1"
},
"Amazon.Lambda.Serialization.Json": "1.3.0"
439
Signaturas del controlador
},
"frameworks": {
"netcoreapp1.0": {
"imports": "dnxcore50"
}
}
}
El ejemplo siguiente ilustra la flexibilidad que puede obtenerse especificando el serializador

predeterminado de Json.NET en un método y otro elegido por el usuario en otro método:
public class ProductService{

[LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
public Product DescribeProduct(DescribeProductRequest request)
{
return catalogService.DescribeProduct(request.Id);
}
[LambdaSerializer(typeof(MyJsonSerializer))]
public Customer DescribeCustomer(DescribeCustomerRequest request)
{
return customerService.DescribeCustomer(request.Id);
}
}
Note
Si utiliza .NET Core 3.1, le recomendamos que utilice el serializador

Amazon.Lambda.Serialization.SystemTextJson. Este paquete proporciona una mejora de
rendimiento sobre Amazon.Lambda.Serialization.Json.
Signaturas del controlador

Cuando cree funciones de Lambda, debe proporcionar una cadena de controlador que indique a AWS
Lambda dónde debe buscar el código que va a invocar. En C#, tiene este formato:
ENSAMBLADO::TIPO::MÉTODO, donde:
• ENSAMBLADO es el nombre del archivo de ensamblado de .NET para la aplicación. Cuando utilice la
CLI de .NET Core para compilar la aplicación, si no ha establecido el nombre del ensamblado con la
opción buildOptions.outputName en project.json, el nombre de ENSAMBLADO será el nombre de
la carpeta que contiene el archivo project. json. Para obtener más información, consulte CLI de .NET
Core (p. 433). En este caso, supongamos que el nombre de la carpeta es HelloWorldApp.
• TIPO es el nombre completo del tipo de controlador, que consta del EspacioDeNombres y del
NombreDeLaClase. En este caso Example.Hello.
• MÉTODO es el nombre del controlador de la función, en este caso, MyHandler.
En definitiva, la signatura tendrá este formato:

Ensamblado::EspacioDeNombres.NombreDeLaClase::NombreDelMétodo.
Ahora, considere el siguiente ejemplo:
using System.IO;
namespace Example
{
440
Serialización de las funciones de Lambda
public class Hello

{
public Stream MyHandler(Stream stream)
{
//function logic
}
}
}
La cadena del controlador sería: HelloWorldApp::Example.Hello::MyHandler.

Important
Si el método especificado en la cadena de controlador está sobrecargado, debe proporcionar la

signatura exacta del método que Lambda debe invocar. AWS Lambda rechazará una signatura
que de otra forma sería válida si la resolución requeriría seleccionar entre varias signaturas
(sobrecargadas).
Serialización de las funciones de Lambda

Para las funciones de Lambda que utilizan tipos de entrada o salida distintos de un objeto Stream, tendrá
que añadir una biblioteca de serialización a la aplicación. Puede hacerlo de las siguientes maneras:
• Utilice el paquete Amazon.Lambda.Serialization.Json de NuGet. Esta biblioteca utiliza

JSON.NET para gestionar la serialización.
Note
Si utiliza .NET Core 3.1, le recomendamos que utilice el serializador

Amazon.Lambda.Serialization.SystemTextJson. Este paquete proporciona una mejora de
rendimiento sobre Amazon.Lambda.Serialization.Json.
• Creando su propia biblioteca de serialización mediante la implementación de la interfaz
ILambdaSerializer, que está disponible formando parte de la biblioteca Amazon.Lambda.Core. La
interfaz define dos métodos:
• T Deserialize<T>(Stream requestStream);
Puede implementar este método para deserializar la carga de solicitud desde la API Invoke en el
objeto que se pasa al controlador de la función de Lambda.
• T Serialize<T>(T response, Stream responseStream);.
Puede implementar este método para serializar el resultado que devuelve el controlador de la función
de Lambda en la carga de respuesta que devuelve la API Invoke.
Puede utilizar cualquier serializador que desee añadiéndolo como una dependencia al archivo
MyProject.csproj.
...
<ItemGroup>
<PackageReference Include="Amazon.Lambda.Core" Version="1.0.0" />
</ItemGroup>
Seguidamente, deberá añadirlo a su archivo AssemblyInfo.cs. Por ejemplo, si utiliza el serializador

predeterminado de Json.NET, esto es lo que debería añadir:
[assembly:LambdaSerializer(typeof(Amazon.Lambda.Serialization.Json.JsonSerializer))]
441
Restricciones del controlador de funciones de Lambda
Note
Puede definir un atributo de serialización personalizado en el nivel de método, que sustituirá

al serializador predeterminado especificado en el nivel de ensamblado. Para obtener más
información, consulte Control de tipos de datos estándar (p. 439).
Restricciones del controlador de funciones de Lambda

Tenga en cuenta que existen algunas restricciones que afectan a la firma del controlador.
• No puede ser unsafe ni utilizar tipos de puntero en la signatura del controlador, aunque el contexto
unsafe puede utilizarse dentro del método del controlador y sus dependencias. Para obtener más
información, consulte unsafe (Referencia de C#).
• No puede pasar un número variable de parámetros utilizando la palabra clave params, ni utilizar
ArgIterator como parámetro de entrada o de retorno que se utiliza para admitir un número variable
de parámetros.
• El controlador no puede ser un método genérico (por ejemplo, IList<T> Sort<T>(IList<T> input)).
• No se admiten los controladores asíncronos con la signatura async void.
Uso de async en funciones C# con AWS Lambda

Si sabe que la función de Lambda requerirá un proceso de larga duración, como cargar archivos grandes
en Amazon S3 o leer una gran cantidad de registros desde DynamoDB, puede utilizar el patrón async/
await. Cuando se utiliza esta firma, Lambda ejecuta la función de forma síncrona y espera a que devuelva
una respuesta o a que se agote el tiempo de espera (p. 54) de ejecución.
public async Task<Response> ProcessS3ImageResizeAsync(SimpleS3Event input)

{
var response = await client.DoAsyncWork(input);
return response;
}
Si utiliza este patrón, debe tener en cuenta algunas consideraciones:
• AWS Lambda no admite métodos async void.

• Si crea una función de Lambda asíncrona sin implementar el operador await, .NET emitirá una
advertencia de compilación y se producirá un comportamiento inesperado. Por ejemplo, algunas
acciones asíncronas se ejecutarán, mientras que otras no. O algunas acciones asíncronas no terminarán
antes de que finalice la ejecución de la función.
public async Task ProcessS3ImageResizeAsync(SimpleS3Event event) // Compiler warning

{
client.DoAsyncWork(input);
}
• La función de Lambda puede incluir varias llamadas asíncronas, que pueden invocarse en paralelo.
Puede utilizar los métodos Task.WhenAll y Task.WhenAny para trabajar con varias tareas. Para
utilizar el método Task.WhenAll, pase una lista de las operaciones en una matriz al método. En el
ejemplo siguiente, tenga en cuenta que si olvida incluir cualquier operación en la matriz, la llamada
puede volver antes de que finalice su operación.
public async Task DoesNotWaitForAllTasks1()

{
// In Lambda, Console.WriteLine goes to CloudWatch Logs.
var task1 = Task.Run(() => Console.WriteLine("Test1"));
442
Contexto

// Lambda may return before printing "Test2" since we never wait on task2.
await Task.WhenAll(task1, task3);
}
Para utilizar el método Task.WhenAny, también se pasa una lista de las operaciones en una matriz al
método. La llamada vuelve tan pronto como finaliza la primera operación, incluso si las demás siguen
ejecutándose.
public async Task DoesNotWaitForAllTasks2()

{
// In Lambda, Console.WriteLine goes to CloudWatch Logs.
// Lambda may return before printing all tests since we're only waiting for one to
finish.
await Task.WhenAny(task1, task2, task3);
}
Objeto context de AWS Lambda en C#

proporciona propiedades con información acerca de la invocación, la función y el entorno de ejecución.

• AwsRequestId: El identificador de la solicitud de invocación.
• RemainingTime (TimeSpan): El número de milisegundos que faltan antes de que se agote el tiempo
de espera.
• Logger: el objeto logger (p. 444) para la función.
El siguiente fragmento de código C# muestra una función de controlador sencilla que imprime parte de la
información de contexto.
public async Task Handler(ILambdaContext context)

{
Console.WriteLine("Function name: " + context.FunctionName);
Console.WriteLine("RemainingTime: " + context.RemainingTime);
443
Registro
await Task.Delay(TimeSpan.FromSeconds(0.42));
Console.WriteLine("RemainingTime after sleep: " + context.RemainingTime);
}
Registro de funciones de AWS Lambda en C#

Para generar registros desde el código de función, puede utilizar los métodos de la clase Console o
cualquier biblioteca de registro que escriba en stdout o en stderr. En el ejemplo siguiente se utiliza la
clase LambdaLogger de la biblioteca Amazon.Lambda.Core (p. 432).
Example src/blank-csharp/Function.cs – registro
public async Task<AccountUsage> FunctionHandler(SQSEvent invocationEvent, ILambdaContext

context)
{
GetAccountSettingsResponse accountSettings;
try
{
accountSettings = await callLambda();
}
catch (AmazonLambdaException ex)
{
throw ex;
}
AccountUsage accountUsage = accountSettings.AccountUsage;
LambdaLogger.Log("ENVIRONMENT VARIABLES: " +
JsonConvert.SerializeObject(System.Environment.GetEnvironmentVariables()));
LambdaLogger.Log("CONTEXT: " + JsonConvert.SerializeObject(context));
LambdaLogger.Log("EVENT: " + JsonConvert.SerializeObject(invocationEvent));
return accountUsage;
}
START RequestId: d1cf0ccb-xmpl-46e6-950d-04c96c9b1c5d Version: $LATEST

ENVIRONMENT VARIABLES:
{
"AWS_EXECUTION_ENV": "AWS_Lambda_dotnetcore2.1",
"AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/blank-csharp-function-WU56XMPLV2XA",
"AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
"AWS_LAMBDA_LOG_STREAM_NAME": "2020/03/27/[$LATEST]5296xmpl084f411d9fb73b258393f30c",
"AWS_LAMBDA_FUNCTION_NAME": "blank-csharp-function-WU56XMPLV2XA",
...
EVENT:
{
"Records": [
{
"MessageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"ReceiptHandle": "MessageReceiptHandle",
"Body": "Hello from SQS!",
"Md5OfBody": "7b270e59b47ff90a553787216d55d91d",
"Md5OfMessageAttributes": null,
"EventSourceArn": "arn:aws:sqs:us-west-2:123456789012:MyQueue",
"EventSource": "aws:sqs",
"AwsRegion": "us-west-2",
444
"Attributes": {
"SentTimestamp": "1523232000000",
"SenderId": "123456789012",
},
...
END RequestId: d1cf0ccb-xmpl-46e6-950d-04c96c9b1c5d
REPORT RequestId: d1cf0ccb-xmpl-46e6-950d-04c96c9b1c5d Duration: 4157.16 ms Billed
XRAY TraceId: 1-5e7e8131-7ff0xmpl32bfb31045d0a3bb SegmentId: 0152xmpl6016310f Sampled: true
El tiempo de ejecución de .NET registra las líneas START, END y REPORT de cada invocación. La línea del

evento.
comandos.
Secciones

CloudWatch Logs.

445
Mediante AWS CLI
Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}


#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
446
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
}
],
}
Errores de funciones de AWS Lambda en C#

Cuando se produzca una excepción en una función de Lambda, Lambda le proporcionará información
sobre la excepción. Las excepciones pueden producirse en dos lugares distintos:
• Inicialización (cuando Lambda carga el código, valida la cadena de controlador y crea una instancia de la
clase, si no es estática).
• La invocación de la función de Lambda.
La información serializada sobre la excepción se devuelve como la carga de un objeto JSON modelado, y
se registra en los logs de CloudWatch.
En la fase de inicialización, pueden producirse excepciones para cadenas de controlador no válidas,

métodos o tipos que no cumplan las reglas (consulte Restricciones del controlador de funciones de
Lambda (p. 442)) o cualquier otro método de validación (como olvidar el atributo serializador y utilizar
POCO como tipo de entrada o salida). Estas excepciones son de tipo LambdaException. Por ejemplo:
447
Errores
"errorType": "LambdaException",
"errorMessage": "Invalid lambda function handler: 'http://this.is.not.a.valid.handler/'.
The valid format is 'ASSEMBLY::TYPE::METHOD'."
}
Si el constructor genera una excepción, el error también es del tipo LambdaException, pero la excepción
generada durante la construcción se proporciona en la propiedad cause, que es un objeto de excepción
modelado:
{
"errorType": "LambdaException",
"errorMessage": "An exception was thrown when the constructor for type
'LambdaExceptionTestFunction.ThrowExceptionInConstructor'
was invoked. Check inner exception for more details.",
"cause": {
"errorType": "TargetInvocationException",
"errorMessage": "Exception has been thrown by the target of an invocation.",
"stackTrace": [
"at System.RuntimeTypeHandle.CreateInstance(RuntimeType type, Boolean publicOnly,
Boolean noCheck, Boolean&canBeCached,
RuntimeMethodHandleInternal&ctor, Boolean& bNeedSecurityCheck)",
"at System.RuntimeType.CreateInstanceSlow(Boolean publicOnly, Boolean skipCheckThis,
Boolean fillCache, StackCrawlMark& stackMark)",
"at System.Activator.CreateInstance(Type type, Boolean nonPublic)",
"at System.Activator.CreateInstance(Type type)"
],
"cause": {
"errorType": "ArithmeticException",
"errorMessage": "Sorry, 2 + 2 = 5",
"stackTrace": [
"at LambdaExceptionTestFunction.ThrowExceptionInConstructor..ctor()"
]
}
}
}
Como muestra el ejemplo, las excepciones internas siempre se conservan (como la propiedad cause) y
pueden anidarse profundamente.
Las excepciones también pueden producirse durante la invocación. En este caso, se conserva el tipo de la
excepción y esta se devuelve directamente como carga y en los logs de CloudWatch. Por ejemplo:
{
"errorType": "AggregateException",
"errorMessage": "One or more errors occurred. (An unknown web exception occurred!)",
"stackTrace": [
"at System.Threading.Tasks.Task.ThrowIfExceptional(Boolean
includeTaskCanceledExceptions)",
"at System.Threading.Tasks.Task`1.GetResultCore(Boolean waitCompletionNotification)",
"at lambda_method(Closure , Stream , Stream , ContextInfo )"
],
"cause": {
"errorType": "UnknownWebException",
"errorMessage": "An unknown web exception occurred!",
"stackTrace": [
"at LambdaDemo107.LambdaEntryPoint.<GetUriResponse>d__1.MoveNext()",
"--- End of stack trace from previous location where exception was thrown ---",
"at System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)",
"at
System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task
task)",
"at System.Runtime.CompilerServices.TaskAwaiter`1.GetResult()",
"at LambdaDemo107.LambdaEntryPoint.<CheckWebsiteStatus>d__0.MoveNext()"
448
Errores
],
"cause": {
"errorType": "WebException",
"errorMessage": "An error occurred while sending the request. SSL peer certificate or
SSH remote key was not OK",
"stackTrace": [
"at System.Net.HttpWebRequest.EndGetResponse(IAsyncResult asyncResult)",
"at System.Threading.Tasks.TaskFactory`1.FromAsyncCoreLogic(IAsyncResult iar,
Func`2 endFunction, Action`1 endAction, Task`1 promise, Boolean requiresSynchronization)",
"at
task)",
"at System.Runtime.CompilerServices.TaskAwaiter`1.GetResult()",
"at LambdaDemo107.LambdaEntryPoint.<GetUriResponse>d__1.MoveNext()"
],
"cause": {
"errorType": "HttpRequestException",
"errorMessage": "An error occurred while sending the request.",
"stackTrace": [
"at
task)",
"at System.Net.Http.HttpClient.<FinishSendAsync>d__58.MoveNext()",
"at
task)",
"at System.Net.HttpWebRequest.<SendRequest>d__63.MoveNext()",
"at
task)",
"at System.Net.HttpWebRequest.EndGetResponse(IAsyncResult asyncResult)"
],
"cause": {
"errorType": "CurlException",
"errorMessage": "SSL peer certificate or SSH remote key was not OK",
"stackTrace": [
"at System.Net.Http.CurlHandler.ThrowIfCURLEError(CURLcode error)",
"at
System.Net.Http.CurlHandler.MultiAgent.FinishRequest(StrongToWeakReference`1 easyWrapper,
CURLcode messageResult)"
]
}
}
}
}
}
El método con el que se comunica la información del error depende del tipo de invocación:
• Tipo de invocación RequestResponse (es decir, ejecución síncrona): en este caso, se obtiene el
mensaje de error.
Por ejemplo, si invoca una función de Lambda utilizando la consola de Lambda, RequestResponse
siempre es el tipo de invocación, y la consola muestra la información de error devuelta por AWS Lambda
en la sección Execution result (Resultado de ejecución) de la consola.
• Tipo de invocación Event (es decir, ejecución asíncrona): en este caso, AWS Lambda no devuelve
nada. En su lugar, registra la información de error en las métricas de CloudWatch Logs y CloudWatch.
449
Tracing
En función del origen de eventos, AWS Lambda puede volver a intentar la ejecución de la función
de Lambda que ha fallado. Para obtener más información, consulte Control de errores y reintentos
automáticos en AWS Lambda (p. 119).
Instrumentación de código C# en AWS Lambda



Precios
450
Tracing
Puede instrumentar su código de función para registrar metadatos y rastrear llamadas descendentes. Para
registrar detalles sobre las llamadas que realiza su función a otros recursos y servicios, use el SDK de X-
Ray para .NET. Para obtener el SDK, agregue los paquetes AWSXRayRecorder al archivo de proyecto.
Example src/blank-csharp/blank-csharp.csproj
<PropertyGroup>
<TargetFramework>netcoreapp3.1</TargetFramework>
<GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
<AWSProjectType>Lambda</AWSProjectType>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
<PackageReference Include="Amazon.Lambda.Core" Version="1.1.0" />
<PackageReference Include="Amazon.Lambda.SQSEvents" Version="1.1.0" />
<PackageReference Include="AWSSDK.Core" Version="3.3.104.38" />
<PackageReference Include="AWSSDK.Lambda" Version="3.3.108.11" />
<PackageReference Include="AWSXRayRecorder.Core" Version="2.6.2" />
<PackageReference Include="AWSXRayRecorder.Handlers.AwsSdk" Version="2.7.2" />
</ItemGroup>
</Project>
Para instrumentar clientes SDK de AWS, llame al método RegisterXRayForAllServices en su código

de inicialización.
Example src/blank-csharp/Function.cs: Inicializar X-Ray
static async void initialize() {

AWSSDKHandler.RegisterXRayForAllServices();
lambdaClient = new AmazonLambdaClient();
await callLambda();
451

con anotaciones y metadatos. Para obtener más información, consulte SDK de X-Ray para .NET en Guía
Secciones

Lambda

function».
452
publicada.

CloudFormation
Resources:
function:
Properties:
TracingConfig:
Mode: Active
...

Resources:
function:
Properties:
Tracing: Active
...
453
Entorno de desarrollo

con PowerShell
En las siguientes secciones se explica cómo se aplican los conceptos fundamentales y los patrones de
programación comunes al crear código de funciones de Lambda en PowerShell.
Runtimes de .NET
Note
Aplicaciones de Lambda de ejemplo en PowerShell
• blank-powershell: una función de PowerShell que muestra el uso de registro, las variables de
entorno y el SDK de AWS.
Antes de comenzar, primero debe configurar un entorno de desarrollo de PowerShell. Para obtener
instrucciones al respecto, consulte Configuración del entorno de desarrollo de PowerShell (p. 454).
Para obtener más información sobre cómo utilizar el módulo AWSLambdaPSCore para descargar
proyectos de muestra de PowerShell a partir de plantillas, cómo crear paquetes de implementación de
PowerShell y cómo implementar funciones de PowerShell en la nube de AWS, consulte Paquete de
implementación de AWS Lambda en PowerShell (p. 455).
Temas
• Configuración del entorno de desarrollo de PowerShell (p. 454)
• Controlador de funciones de AWS Lambda en PowerShell (p. 457)
• Objeto context de AWS Lambda en PowerShell (p. 458)
• Registro de funciones AWS Lambda en PowerShell (p. 458)
Configuración del entorno de desarrollo de

PowerShell
Para configurar su entorno de desarrollo para escribir scripts de PowerShell, haga lo siguiente:
454
1. Instale la versión correcta de PowerShell – la compatibilidad de Lambda con PowerShell se basa

en la versión PowerShell Core 6.0 multiplataforma. Esto significa que puede desarrollar funciones
de Lambda de PowerShell en Windows, Linux o Mac. Si no dispone de esta versión de PowerShell
instalada, puede encontrar instrucciones en Instalación de PowerShell Core.
2. Instale el SDK de .NET Core 3.1 – dado que PowerShell Core se basa en .NET Core, la
compatibilidad de Lambda con PowerShell utiliza el mismo tiempo de ejecución de Lambda de .NET
Core 3.1 para las funciones de Lambda tanto de .NET Core como de PowerShell. Los nuevos cmdlets
de publicación de Lambda de PowerShell utilizan el SDK de .NET Core 3.1 para crear el paquete de
implementación de Lambda. El SDK de .NET Core 3.1 está disponible en Descargas de .NET en el
sitio web de Microsoft. Asegúrese de instalar el SDK, no la instalación en tiempo de ejecución.
3. Instale el módulo AWSLambdaPSCore – Puede instalarlo desde PowerShell Gallery, o bien mediante
el siguiente comando del shell de PowerShell Core:
Install-Module AWSLambdaPSCore -Scope CurrentUser
4. (Opcional) Instale Herramientas de AWS para PowerShell – Puede instalar la versión de AWS.Tools
modularizada o AWSPOwerShell.NetCore de un solo módulo en PowerShell Core 6.0 para utilizar
la API de Lambda dentro de su entorno de PowerShell. Para obtener instrucciones, consulte la
instalación de Herramientas de AWS para PowerShell.

PowerShell
Un paquete de implementación de Lambda para PowerShell es un archivo ZIP que contiene su script
de PowerShell, los módulos de PowerShell necesarios para su script de PowerShell y los ensamblados
necesarios para alojar PowerShell Core.
El módulo AWSLambdaPSCore tiene los siguientes nuevos cmdlets para ayudarle a crear y publicar las
funciones de Lambda para PowerShell.
AWSLambdaPSCore Cmdlets
• Get-AWSPowerShellLambdaTemplate: devuelve una lista de plantillas de introducción.

• New-AWSPowerShellLambda: crea un script de PowerShell inicial basado en una plantilla.
• Publish-AWSPowerShellLambda: publica un script de PowerShell determinado en Lambda.
• New-Lambda AWSPowerShellLambdaPackage: crea un paquete de implementación Lambda que se
puede utilizar en un sistema de CI/CD para la implementación.
Para que le resulte más fácil empezar a escribir e invocar un script de PowerShell con Lambda, puede
utilizar el cmdlet New-AWSPowerShellLambda para crear un script de inicio basado en una plantilla.
Puede utilizar el cmdlet Publish-AWSPowerShellLambda para implementar su script en AWS Lambda.
A continuación, puede probar el script ya sea a través de la línea de comandos o de la consola.
Para crear un nuevo script de PowerShell, cargarlo y probarlo, siga este procedimiento:
1. Ejecute el siguiente comando para ver la lista de plantillas disponibles:
PS C:\> Get-AWSPowerShellLambdaTemplate
Template Description
-------- -----------
Basic Bare bones script
455
CodeCommitTrigger Script to process AWS CodeCommit Triggers

...
2. Ejecute el siguiente comando para crear un script de muestra basado en la plantilla Basic:
New-AWSPowerShellLambda -ScriptName MyFirstPSScript -Template Basic
Se creará un nuevo archivo denominado MyFirstPSScript.ps1 en un nuevo subdirectorio del

directorio actual. El nombre del directorio se basa en el parámetro -ScriptName. Puede utilizar el
parámetro -Directory para elegir un directorio alternativo.
Puede ver que el nuevo archivo tiene el siguiente contenido:
# PowerShell script file to be executed as a AWS Lambda function.

#
# When executing in Lambda the following variables will be predefined.
# $LambdaInput - A PSObject that contains the Lambda function input data.
# $LambdaContext - An Amazon.Lambda.Core.ILambdaContext object that contains
information about the currently running Lambda environment.
#
# The last item in the PowerShell pipeline will be returned as the result of the Lambda
function.
#
# To include PowerShell modules with your Lambda function, like the
AWSPowerShell.NetCore module, add a "#Requires" statement
# indicating the module and version.
#Requires -Modules @{ModuleName='AWSPowerShell.NetCore';ModuleVersion='3.3.618.0'}
# Uncomment to send the input to CloudWatch Logs

# Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)
3. Para ver cómo se envían los mensajes de registro desde su secuencia de comandos de PowerShell a
CloudWatch Logs, anule el comentario de la línea Write-Host del script de muestra.
Para demostrar cómo puede devolver los datos de sus funciones de Lambda, añada una nueva línea
al final del script con $PSVersionTable. Esto añadirá $PSVersionTable a la canalización de
PowerShell. Una vez que el script de PowerShell se ha completado, el último objeto en la canalización
de PowerShell son los datos de devolución de la función de Lambda. $PSVersionTable es una
variable global de PowerShell que también proporciona información sobre el entorno en ejecución.
Después de realizar estos cambios, las dos últimas líneas del script de muestra tienen un aspecto
similar al siguiente:
Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 5)

$PSVersionTable
4. Después de editar el archivo MyFirstPSScript.ps1, cambie el directorio a la ubicación del script.

Después, ejecute el siguiente comando para publicar el script en AWS Lambda:
Publish-AWSPowerShellLambda -ScriptPath .\MyFirstPSScript.ps1 -Name MyFirstPSScript -

Region us-east-2
Tenga en cuenta que el parámetro -Name especifica el nombre de la función de Lambda, que aparece
en la consola de Lambda. Puede utilizar esta función para invocar manualmente a su script.
5. Invoque su función con el comando invoke de la CLI de AWS.
> aws lambda invoke --function-name MyFirstPSScript out
456
Controlador
Controlador de funciones de AWS Lambda en

PowerShell
Cuando se invoca una función de Lambda, el controlador de Lambda invoca al script de PowerShell.
Cuando el script de PowerShell se invoca, se predefinen las siguientes variables:
• $ LambdaInput: un PSObject que contiene la entrada al controlador. Esta entrada puede estar
formada por datos de eventos (publicados por un origen de eventos) o por una entrada personalizada
que proporcione, como una cadena o cualquier objeto de datos personalizado.
• $LambdaContext: un objeto Amazon.Lambda.Core.ILambdaContext que puede utilizar para obtener
acceso a información sobre la ejecución actual, como el nombre de la función actual, el límite de
memoria, el tiempo de ejecución restante y el registro.
Por ejemplo, fíjese en el siguiente código de ejemplo de PowerShell.

Write-Host 'Function Name:' $LambdaContext.FunctionName
Este script devuelve la propiedad FunctionName que obtiene de la variable $LambdaContext.

Note
Es necesario que utilice la instrucción #Requires dentro de sus scripts de PowerShell para
indicar los módulos de los que dependen los scripts. Esta instrucción realiza dos tareas
importantes. 1) Comunica a otros desarrolladores los módulos que utiliza el script; y 2) identifica
los módulos dependientes que necesitan las herramientas de AWS PowerShell para incluir
en el paquete con el script, como parte de la implementación. Para obtener más información
sobre la instrucción #Requires en PowerShell, consulte Acerca de los requisitos. Para obtener
más información sobre los paquetes de implementación de PowerShell, consulte Paquete de
implementación de AWS Lambda en PowerShell (p. 455).
Si su función de Lambda para PowerShell utiliza los cmdlets de AWS PowerShell,
asegúrese de establecer una instrucción #Requires que haga referencia al módulo
AWSPowerShell.NetCore, que admite PowerShell Core y no el módulo AWSPowerShell, que
solo admite Windows PowerShell. Además, asegúrese de utilizar la versión 3.3.270.0 o posterior
de AWSPowerShell.NetCore, que optimiza el proceso de importación del cmdlet. Si utiliza una
versión anterior, experimentará unos arranques en frío más largos. Para obtener más información,
consulte Herramientas de AWS para PowerShell.
Devolución de datos
Algunas invocaciones Lambda están destinadas a devolver los datos a su intermediario. Por ejemplo, si
una invocación se hizo en respuesta a una solicitud web procedente de API Gateway, entonces nuestra
función de Lambda debe devolver la respuesta. Para PowerShell Lambda, el último objeto que se añade a
la canalización de PowerShell son los datos de devolución de la invocación de Lambda. Si el objeto es una
cadena, los datos se devuelven tal cual. De lo contrario, el objeto se convierte en JSON mediante el uso
del cmdlet ConvertTo-Json.
Por ejemplo, observe la siguiente instrucción de PowerShell, que añade $PSVersionTable a la

canalización de PowerShell:
$PSVersionTable
457
Contexto
Una vez que el script de PowerShell ha finalizado, el último objeto en la canalización de PowerShell son los
datos de devolución de la función de Lambda. $PSVersionTable es una variable global de PowerShell
que también proporciona información sobre el entorno en ejecución.
Objeto context de AWS Lambda en PowerShell

Cuando Lambda ejecuta su función, pasa información de context haciendo que una variable
$LambdaContext esté disponible para el controlador (p. 457). Esta variable proporciona métodos y
propiedades con información acerca de la invocación, la función y el entorno de ejecución.

• AwsRequestId: El identificador de la solicitud de invocación.
• RemainingTime: El número de milisegundos que faltan antes de que se agote el tiempo de espera.
• Logger: el objeto logger (p. 458) para la función.
El siguiente fragmento de código PowerShell muestra una función de controlador sencilla que imprime
parte de la información de contexto.

Write-Host 'Function name:' $LambdaContext.FunctionName
Write-Host 'Remaining milliseconds:' $LambdaContext.RemainingTime.TotalMilliseconds
Write-Host 'Log group name:' $LambdaContext.LogGroupName
Write-Host 'Log stream name:' $LambdaContext.LogStreamName
Registro de funciones AWS Lambda en PowerShell

Para generar registros desde el código de su función, puede usar cmdlets en Microsoft.PowerShell.Utility o
en cualquier módulo de registro que escriba en stdout o en stderr. El siguiente ejemplo utiliza Write-
Host.
Example function/Handler.ps1: registro
458
Registro
Write-Host `## Environment variables

Write-Host AWS_LAMBDA_FUNCTION_VERSION=$Env:AWS_LAMBDA_FUNCTION_VERSION
Write-Host AWS_LAMBDA_LOG_GROUP_NAME=$Env:AWS_LAMBDA_LOG_GROUP_NAME
Write-Host AWS_LAMBDA_LOG_STREAM_NAME=$Env:AWS_LAMBDA_LOG_STREAM_NAME
Write-Host AWS_EXECUTION_ENV=$Env:AWS_EXECUTION_ENV
Write-Host AWS_LAMBDA_FUNCTION_NAME=$Env:AWS_LAMBDA_FUNCTION_NAME
Write-Host PATH=$Env:PATH
Write-Host `## Event
Write-Host (ConvertTo-Json -InputObject $LambdaInput -Compress -Depth 3)
START RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed Version: $LATEST

Importing module ./Modules/AWSPowerShell.NetCore/3.3.618.0/AWSPowerShell.NetCore.psd1
[Information] - ## Environment variables
[Information] - AWS_LAMBDA_FUNCTION_VERSION=$LATEST
[Information] - AWS_LAMBDA_LOG_GROUP_NAME=/aws/lambda/blank-powershell-
function-18CIXMPLHFAJJ
[Information] - AWS_LAMBDA_LOG_STREAM_NAME=2020/04/01/
[$LATEST]53c5xmpl52d64ed3a744724d9c201089
[Information] - AWS_EXECUTION_ENV=AWS_Lambda_dotnetcore2.1_powershell_1.0.0
[Information] - AWS_LAMBDA_FUNCTION_NAME=blank-powershell-function-18CIXMPLHFAJJ
[Information] - PATH=/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin
[Information] - ## Event
[Information] -
{
"Records": [
{
"messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
"attributes": {
"SentTimestamp": "1523232000000",
"SenderId": "123456789012",
},
...
END RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed
REPORT RequestId: 56639408-xmpl-435f-9041-ac47ae25ceed Duration: 3906.38 ms Billed
XRAY TraceId: 1-5e843da6-733cxmple7d0c3c020510040 SegmentId: 3913xmpl20999446 Sampled: true
El tiempo de ejecución de .NET registra las líneas START, END y REPORT de cada invocación. La línea del

evento.
459
comandos.
Secciones

CloudWatch Logs.

Mediante AWS CLI


{
"StatusCode": 200,
"LogResult":
}

460
Mediante AWS CLI
#!/bin/bash
sleep 15
out) --limit 5
$ ./get-logs.sh
{
"StatusCode": 200,
}
{
"events": [
{
"timestamp": 1559763003171,
$LATEST\n",
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003173,
},
{
"timestamp": 1559763003218,
},
{
"timestamp": 1559763003218,
}
],
}
461
Errores de la función AWS Lambda en PowerShell.

Si su función de Lambda tiene un error al terminar, AWS Lambda reconoce el error, serializa la información
de error en JSON y lo devuelve.
Considere la siguiente instrucción de ejemplo de script de PowerShell:
throw 'The Account is not found'
Al invocar esta función de Lambda, se genera un error de terminación y AWS Lambda devuelve el
siguiente mensaje de error:
{
"errorMessage": "The Account is not found",
"errorType": "RuntimeException"
}
Tenga en cuenta que errorType es RuntimeException, que es la excepción predeterminada generada

por PowerShell. Puede utilizar los tipos de error personalizados generando el error de la siguiente forma:
throw @{'Exception'='AccountNotFound';'Message'='The Account is not found'}
El mensaje de error se serializa con errorType establecido en AccountNotFound:
{
"errorMessage": "The Account is not found",
"errorType": "AccountNotFound"
}
Si no necesita un mensaje de error, puede generar una cadena con el formato de un código de error. El
formato de código de error requiere que la cadena empiece con un carácter y solo contenga letras y dígitos
a continuación, sin espacios ni símbolos.
Por ejemplo, si su función de Lambda contiene lo siguiente:
throw 'AccountNotFound'
El error se serializa como se indica a continuación:
{
"errorMessage": "AccountNotFound",
"errorType": "AccountNotFound"
}
462
Monitorización y solución de
problemas de aplicaciones basadas
en Lambda
AWS Lambda monitoriza automáticamente funciones Lambda en su nombre e informa sobre las métricas
a través de Amazon CloudWatch. Para ayudarle a monitorizar el código mientras se ejecuta, Lambda
controla automáticamente el número de solicitudes, la duración de la ejecución por solicitud y el número de
solicitudes que generan un error. También publica las métricas de CloudWatch asociadas. Puede utilizar
estas métricas para configurar alarmas personalizadas de CloudWatch.
La consola Lambda proporciona un panel de monitorización (p. 464) integrado para cada una de sus
funciones y aplicaciones.
Para monitorizar una función

3. Elija Monitoring (Monitorización).
Precios
CloudWatch tiene una capa gratuita perpetua Más allá del umbral de capa gratuita, CloudWatch
hace cargos por métricas, paneles, alarmas, registros e información. Consulte Precios de
CloudWatch para obtener más información.
Cada vez que se invoca la función, Lambda registra métricas (p. 464) de la solicitud, la respuesta
de la función y el estado general de la función. Puede utilizar métricas para establecer alarmas que se
activan cuando el rendimiento de la función se degrada o cuando esté cerca de alcanzar los límites de
concurrencia en la región actual.
Para depurar y validar que el código funciona como se esperaba, puede generar registros con la
funcionalidad de registro estándar para el lenguaje de programación. El tiempo de ejecución de Lambda
carga la salida de registro de su función en CloudWatch Logs. Puede ver los registros (p. 467) en la
consola de CloudWatch Logs o en la de Lambda, o bien en la línea de comandos.
Además de supervisar registros y métricas en CloudWatch, puede utilizar AWS X-Ray para rastrear y
depurar solicitudes atendidas por la aplicación. Para obtener más información, consulte Uso de AWS
Lambda con AWS X-Ray (p. 311).
Secciones
• Monitorización de funciones en la consola de AWS Lambda (p. 464)
• Trabajar con métricas de funciones de AWS Lambda (p. 464)
• Acceso a los registros de Amazon CloudWatch para AWS Lambda (p. 467)
463
Consola de administración
Monitorización de funciones en la consola de AWS

Lambda
AWS Lambda monitoriza funciones en su nombre y envía métricas a Amazon CloudWatch. Las métricas
incluyen el total de solicitudes, la duración y las tasas de errores. La consola de Lambda crea gráficos para
estas métricas y las muestra en la página Monitoring (Monitorización) de cada función.
Para obtener acceso a la consola de monitorización

La consola ofrece los gráficos siguientes.
Gráficos de monitorización de Lambda
• Invocations (Invocaciones): el número de veces que se invocó la función en cada período de 5 minutos.
• Duration (Duración): los tiempos promedio, mínimo y máximo de ejecución.
• Error count and success rate (%) (Número de errores y tasa de éxito (%)): el número de errores y el
porcentaje de ejecuciones completadas sin errores.
• Throttles (Limitaciones): el número de veces que se produjo un error en la ejecución debido a los límites
de simultaneidad.
• IteratorAge: en los orígenes de eventos de flujo, la antigüedad del último elemento del lote cuando
Lambda lo recibe e invoca la función.
• Errores de entrega asincrónicos: Número de errores que se produjeron cuando Lambda intentó escribir
en una cola de mensajes fallidos o destino.
• Ejecuciones simultáneas: Número de instancias de función que están procesando eventos.
Para ver la definición de un gráfico en CloudWatch, elija View in metrics (Ver en métricas) en el menú de
la parte superior derecha del gráfico. Para obtener más información acerca de las métricas que Lambda
registra, consulte Trabajar con métricas de funciones de AWS Lambda (p. 464).
La consola también muestra los informes de CloudWatch Logs Insights compilados a partir de información
en sus registros de función. Puede añadir estos informes a un panel personalizado en la consola de
CloudWatch Logs. Utilice las consultas como punto de partida para sus propios informes.
Para ver una consulta, elija View en CloudWatch Logs Insights (Ver en CloudWatch Logs Insights) en el
menú de la parte superior derecha del informe.
Trabajar con métricas de funciones de AWS

Lambda
Cuando la función termina de procesar un evento, Lambda envía métricas sobre la invocación a Amazon
CloudWatch. Puede crear gráficos y paneles con estas métricas en la consola de CloudWatch y establecer
alarmas para responder a cambios en el uso, el rendimiento o las tasas de error. Utilice las dimensiones
para filtrar y clasificar métricas de funciones por nombre de función, alias o versión.
Para ver métricas en la consola de CloudWatch
1. Abra la página Metrics (métricas) de la consola de Amazon CloudWatch (espacio de nombres AWS/
Lambda).
464
Uso de métricas de invocación
2. Elija una dimensión.
• Por nombre de función (FunctionName): ver métricas agregadas de todas las versiones y alias de
una función.
• Por recurso (Resource): ver las métricas de una versión o el alias de una función.
• Por versión ejecutada (ExecutedVersion): ver métricas para una combinación de alias y versión.
Utilice la dimensión ExecutedVersion para comparar las tasas de error de dos versiones de una
función que son objetivos de un alias ponderado (p. 72).
• En todas las funciones (ninguna): ver métricas agregadas de todas las funciones de la región de
AWS actual.
3. Elija métricas para agregarlas al gráfico.
De forma predeterminada, los gráficos utilizan la estadística Sum para todas las métricas. Para elegir una
estadística diferente y personalizar el gráfico, utilice las opciones de la pestaña Métricas Gráficas .
La marca temporal de una métrica refleja cuándo se invocó la función. Dependiendo de la duración de la
ejecución, esto puede ser varios minutos antes de la emisión de la métrica. Si, por ejemplo, su función
tiene un tiempo de espera de 10 minutos, busque más de 10 minutos en el pasado para obtener métricas
precisas.
Para obtener más información acerca de CloudWatch, consulte la Guía del usuario de Amazon
CloudWatch.
Secciones
• Uso de métricas de invocación (p. 465)
• Uso de métricas de desempeño (p. 466)
• Uso de métricas de simultaneidad (p. 466)
Uso de métricas de invocación

Las métricas de invocación son indicadores binarios del resultado de una invocación. Por ejemplo, si la
función devuelve un error, Lambda envía la métrica Errors con un valor de 1. Para obtener un recuento
del número de errores de función que se produjeron cada minuto, vea la Sum de la métrica Errors con un
período de un minuto.
Debe ver las siguientes métricas con la estadística Sum.
Métricas de invocación
• Invocations: el número de veces que se ejecuta el código de función, incluidas las ejecuciones
exitosas y las ejecuciones que dan lugar a un error de función. Las invocaciones no se registran si la
solicitud de invocación se limita o da lugar a un error de invocación (p. 589). Esto equivale al número
de solicitudes facturadas.
• Errors: el número de invocaciones que dan lugar a un error de función. Los errores de función
incluyen excepciones lanzadas por su código y excepciones lanzadas por el tiempo de ejecución de
Lambda. El motor de ejecución devuelve errores para problemas como tiempos de espera y errores de
configuración. Para calcular la tasa de error, divida el valor de Errors por el valor de Invocations.
• DeadLetterErrors: para la invocación asíncrona (p. 101), el número de veces que Lambda intenta
enviar un evento a una cola de mensajes fallidos pero falla. Pueden producirse errores de mensaje
fallido debido a errores de permisos, recursos mal configurados o límites de tamaño.
• DestinationDeliveryFailures: para la invocación asíncrona, el número de veces que Lambda
intenta enviar un evento a un destino (p. 27) pero falla. Pueden producirse errores de entrega debido a
errores de permisos, recursos mal configurados o límites de tamaño.
465
Uso de métricas de desempeño
• Throttles: el número de solicitudes de invocación que se han limitado. Cuando todas las instancias
de función están procesando solicitudes y no hay concurrencia disponible para escalar, Lambda rechaza
solicitudes adicionales con TooManyRequestsException (p. 589). Las solicitudes aceleradas y otros
errores de invocación no cuentan como Invocations o Errors.
• ProvisionedConcurrencyInvocations: el número de veces que su código de función se ejecuta
en concurrencia aprovisionada (p. 62).
• ProvisionedConcurrencySpilloverInvocations: el número de veces que su código de función
se ejecuta en concurrencia estándar cuando toda concurrencia aprovisionada está en uso.
Uso de métricas de desempeño

Las métricas de desempeño proporcionan detalles de rendimiento sobre una única invocación. Por
ejemplo, la métrica Duration indica la cantidad de tiempo en milisegundos que la función gasta
procesando un evento. Para obtener una idea de la rapidez con la que su función procesa eventos,
consulte estas métricas con la estadística Average o Max.
Métricas de desempeño
• Duration: la cantidad de tiempo que el código de función pasa procesando un evento. Para el primer
evento procesado por una instancia de su función, esto incluye el tiempo de inicialización (p. 20). La
duración facturada de una invocación es el valor de Duration redondeado hacia arriba a los 100
milisegundos más cercanos.
• IteratorAge: para las asignaciones de origen de eventos (p. 109) que leen desde secuencias, la
antigüedad del último registro del evento. La antigüedad es la cantidad de tiempo entre cuando la
secuencia recibe el registro y cuando la asignación de origen de eventos envía el evento a la función.
Duration también admite estadísticas percentiles. Utilice percentiles para excluir valores atípicos que
sesgan las estadísticas medias y máximas. Por ejemplo, la estadística P95 muestra la duración máxima
del 95 por ciento de las ejecuciones, excluyendo el 5 por ciento más lento.
Uso de métricas de simultaneidad

Lambda informa de las métricas de concurrencia como un recuento agregado del número de instancias
que procesan eventos en una función, versión, alias o región de AWS. Para ver lo cerca que está de
alcanzar los límites de concurrencia, consulte estas métricas con la estadística Max.
Métricas de simultaneidad
• ConcurrentExecutions: número de instancias de función que están procesando eventos. Si este

número alcanza la cuota de ejecuciones simultáneas (p. 31) para la región o el límite de simultaneidad
reservado (p. 62) que configuró en la función, se limitarán las solicitudes de invocación adicionales.
• ProvisionedConcurrentExecutions: el número de instancias de función que están procesando
eventos en concurrencia aprovisionada (p. 62). Para cada invocación de un alias o versión con
simultaneidad aprovisionada, Lambda emite el recuento actual.
• ProvisionedConcurrencyUtilization: para una versión o alias, el valor de
ProvisionedConcurrentExecutions dividido entre la cantidad total de concurrencia aprovisionada
asignada. Por ejemplo, .5 indica que el 50 por ciento de la simultaneidad aprovisionada asignada está
en uso.
• UnreservedConcurrentExecutions: para una región de AWS, el número de eventos que están
procesando funciones que no tienen concurrencia reservada.
466
Acceso a los registros de Amazon CloudWatch para

AWS Lambda
AWS Lambda monitoriza automáticamente las funciones de Lambda en su nombre, e informa sobre las
métricas a través de Amazon CloudWatch. Para ayudarle a solucionar problemas relacionados con los
errores de una función, Lambda registra todas las solicitudes gestionadas por la función, y almacena
automáticamente los registros generados por el código a través de Amazon CloudWatch Logs.
Puede introducir instrucciones de registro en el código comprobar que el código está funcionando según lo
previsto. Lambda se integra automáticamente con CloudWatch Logs y envía todos los registros generados
por el código a un grupo de CloudWatch Logs asociado a una función de Lambda, denominada /aws/
lambda/<nombre de la función>. Para obtener más información acerca de los grupos de registros
y cómo acceder a ellos a través de la consola de CloudWatch, consulte Monitorización del sistema, la
aplicación y los archivos de registro personalizados en la Guía del usuario de Amazon CloudWatch.
Puede ver los registros de Lambda mediante la consola de Lambda, la consola de CloudWatch, la AWS
CLI o la API de CloudWatch. El siguiente procedimiento muestra cómo ver los registros utilizando la
consola de Lambda.
Note
No se aplican cargos adicionales por utilizar los registros de Lambda; no obstante, sí se aplican
los cargos estándar de CloudWatch Logs. Para obtener más información, consulte los precios de
CloudWatch.
Para ver los registro mediante la consola de Lambda

467
Se muestra una representación gráfica de las métricas de la función de Lambda.

4. Elija View logs in CloudWatch (Ver registros en CloudWatch).
Lambda utiliza los permisos de la función para cargar los registros en CloudWatch Logs. Si no ve registros
en la consola, compruebe los permisos del rol de ejecución (p. 33).
468
Protección de los datos
Seguridad en AWS Lambda

La seguridad en la nube de AWS es la mayor prioridad. Como cliente de AWS, se beneficiará de una
arquitectura de red y un centro de datos diseñados para satisfacer los requisitos de seguridad de las
organizaciones más exigentes.
La seguridad es una responsabilidad compartida entre AWS y usted. El modelo de responsabilidad

compartida la describe como seguridad de la nube y seguridad en la nube:
• Seguridad de la nube: AWS es responsable de proteger la infraestructura que ejecuta servicios de

AWS en la nube de AWS. AWS también proporciona servicios que puede utilizar de forma segura.
Auditores externos prueban y verifican periódicamente la eficacia de nuestra seguridad en el marco
de los programas de conformidad de AWS. Para obtener más información acerca de los programas de
conformidad que se aplican a AWS Lambda, consulte Servicios de AWS en el ámbito del programa de
conformidad.
• Seguridad en la nube: su responsabilidad viene determinada por el servicio de AWS que utilice. También
es responsable de otros factores, incluida la confidencialidad de los datos, los requisitos de la empresa y
la legislación y los reglamentos aplicables.
Esta documentación le ayuda a comprender cómo aplicar el modelo de responsabilidad compartida cuando
se utiliza Lambda. En los siguientes temas, se le mostrará cómo configurar Lambda para satisfacer sus
objetivos de seguridad y conformidad. También puede aprender a utilizar otros servicios de AWS que le
ayudan a supervisar y proteger sus recursos de Lambda.
Temas
• Protección de los datos en AWS Lambda (p. 469)
• Administración de identidad y acceso en AWS Lambda (p. 471)
• Validación de la conformidad de AWS Lambda (p. 479)
• Resiliencia de AWS Lambda (p. 479)
• Seguridad de la infraestructura en AWS Lambda (p. 480)
• Configuración y análisis de vulnerabilidades en AWS Lambda (p. 481)
Protección de los datos en AWS Lambda

AWS Lambda cumple los requisitos del modelo de responsabilidad compartida de AWS, que incluye
reglamentos y directrices para la protección de los datos. AWS es responsable de proteger la
infraestructura global que ejecuta todos los servicios de AWS. AWS mantiene el control de los datos
alojados en esta infraestructura, incluidos los controles de configuración de la seguridad para el tratamiento
del contenido y los datos personales de los clientes. Los clientes de AWS y los socios de APN, que actúan
como controladores o procesadores de datos, son responsables de todos los datos personales que
colocan en la nube de AWS.
Para fines de protección de datos, le recomendamos proteger las credenciales de la cuenta de AWS y
configurar cuentas de usuario individuales con AWS Identity and Access Management (IAM), de modo que
a cada usuario se le concedan únicamente los permisos necesarios para llevar a cabo su trabajo. También
le recomendamos proteger sus datos de las siguientes formas:
• Utilice la autenticación multifactor (MFA) con cada cuenta.

• Utilice SSL/TLS para comunicarse con los recursos de AWS.
• Configure la API y el registro de actividad del usuario con AWS CloudTrail.
469
Cifrado en tránsito
• Utilice las soluciones de cifrado de AWS, junto con todos los controles de seguridad predeterminados
dentro de los servicios de AWS.
• Utilice los servicios de seguridad administrados avanzados como, por ejemplo, Amazon Macie, que
ayudan a detectar y proteger los datos personales almacenados en Amazon S3.
Le recomendamos encarecidamente que nunca introduzca información de identificación confidencial,

como, por ejemplo, números de cuenta de sus clientes, en los campos de formato libre, como los nombres
de función y etiquetas. No debe introducir esta información cuando trabaje con Lambda u otros servicios
de AWS a través de la consola, la API, la AWS CLI o los SDK de AWS. Cualquier dato que escriba en
metadatos se puede incluir en los registros de diagnóstico. Cuando proporcione una URL a un servidor
externo, no incluya información de credenciales en la URL para validar la solicitud para ese servidor.
Para obtener más información sobre la protección de datos, consulte la entrada de blog relativa al modelo
de responsabilidad compartida de AWS y GDPR en el blog de seguridad de AWS.
Secciones
• Cifrado en tránsito (p. 470)
• Cifrado en reposo (p. 470)
Cifrado en tránsito
Los puntos de enlace de API de Lambda solo admiten conexiones seguras a través de HTTPS. Al
administrar recursos de Lambda con el SDK de AWS de Consola de administración de AWS o la API de
Lambda, todas las comunicaciones se cifran con Transport Layer Security (TLS).
Cuando conecta su función a un sistema de archivos (p. 91), Lambda utiliza Cifrado en tránsito para todas
las conexiones.
Para obtener una lista completa de los puntos de enlace de API, consulte Regiones y puntos de enlace de
AWS en la AWS General Reference.
Cifrado en reposo
Puede utilizar las variables de entorno para almacenar claves secretas de forma segura para su uso con
funciones de Lambda. Lambda cifra siempre las variables de entorno en reposo.
Además, puede utilizar las siguientes características para personalizar la forma en que se cifran las
variables de entorno.
• Configuración de clave: en una base por función, puede configurar – Lambda para utilizar una clave de
cifrado que se crea y administra en AWS Key Management Service. Estas operaciones se denominan
claves maestras de cliente administradas por el cliente (CMK) o claves administradas por el cliente. Si
no configura una clave administrada por el cliente, Lambda usa una CMK administrada por AWS llamada
aws/lambda, que Lambda crea en su cuenta.
• Ayudantes de cifrado: la consola de – Lambda le permite cifrar los valores de variables de entorno del
lado del cliente, antes de enviarlos a Lambda. Esto mejora aún más seguridad evitando que los secretos
aparezcan sin cifrar en la consola de Lambda, o en la configuración de la función que devuelve la API
de Lambda. La consola también proporciona el código de muestra que puede adaptar para descifrar los
valores en el controlador de la función.
Para obtener más información, consulte Uso de variables de entorno de AWS Lambda (p. 56).
Lambda siempre cifra los archivos que carga en Lambda, incluidos los paquetes de implementación (p. 22)
y los archivos de capas (p. 76).
470
Administración de identidades y accesos
Amazon CloudWatch Logs y AWS X-Ray también cifran los datos de manera predeterminada y se pueden
configurar para utilizar una clave administrada por el cliente. Para obtener más información, consulte Cifrar
datos de registro en CloudWatch Logs y Protección de los datos en AWS X-Ray.
Administración de identidad y acceso en AWS

Lambda
AWS Identity and Access Management (IAM) es un servicio de AWS que ayuda a un administrador a
controlar de forma segura el acceso a los recursos de AWS. Los administradores de IAM controlan quién
puede ser autenticado (iniciar sesión) y estar autorizado (tener permisos) para utilizar los recursos de
Lambda. IAM es un servicio de AWS que se puede utilizar sin costo adicional.
Temas
• Público (p. 471)
• Autenticación con identidades (p. 471)
• Administración de acceso mediante políticas (p. 473)
• Cómo funciona AWS Lambda con IAM (p. 475)
• Ejemplos de políticas basadas en identidades de AWS Lambda (p. 475)
• Solucionar problemas de identidad y acceso en AWS Lambda (p. 477)
Público
La forma en que utilice AWS Identity and Access Management (IAM) difiere, en función del trabajo que
realice en Lambda.
Usuario de servicio: si utiliza el servicio Lambda para realizar su trabajo, su administrador le proporciona
las credenciales y los permisos que necesita. A medida que utilice más características de Lambda
para realizar su trabajo, es posible que necesite permisos adicionales. Entender cómo se administra
el acceso puede ayudarle a solicitar los permisos correctos a su administrador. Si no puede acceder
a una característica en Lambda, consulte Solucionar problemas de identidad y acceso en AWS
Lambda (p. 477).
Administrador de servicio: si está a cargo de los recursos de Lambda en su empresa, probablemente tenga
acceso completo a Lambda. Su trabajo consiste en determinar qué a características y recursos de Lambda
deben acceder sus empleados. A continuación, debe enviar solicitudes a su administrador de IAM para
cambiar los permisos de los usuarios de su servicio. Revise la información de esta página para conocer los
conceptos básicos de IAM. Para obtener más información sobre cómo su empresa puede utilizar IAM con
Lambda, consulte Cómo funciona AWS Lambda con IAM (p. 475).
Administrator de IAM: si es un administrador de IAM, es posible que quiera conocer información sobre
cómo escribir políticas para administrar el acceso a Lambda. Para ver ejemplos de políticas basadas en la
identidad de Lambda que puede utilizar en IAM, consulte Ejemplos de políticas basadas en identidades de
AWS Lambda (p. 475).
Autenticación con identidades

La autenticación es la manera de iniciar sesión en AWS mediante credenciales de identidad. Para obtener
más información acerca del inicio de sesión con la Consola de administración de AWS, consulte La
consola de IAM y la página de inicio de sesión en la Guía del usuario de IAM.
Debe estar autenticado (haber iniciado sesión en AWS) como Usuario de la cuenta raíz de AWS, usuario
de IAM o asumiendo un rol de IAM. También puede utilizar la autenticación de inicio de sesión único de
471
Autenticación con identidades
su empresa o incluso iniciar sesión con Google o Facebook. En estos casos, su administrador habrá
configurado previamente la federación de identidad mediante roles de IAM. Cuando obtiene acceso a AWS
mediante credenciales de otra empresa, asume un rol indirectamente.
Para iniciar sesión directamente en la Consola de administración de AWS, use su contraseña con su
correo electrónico usuario raíz o su nombre de usuario de IAM. Puede obtener acceso a AWS mediante
programación utilizando sus claves de acceso usuario raíz o de usuario de IAM. AWS proporciona SDK y
herramientas de línea de comandos para firmar criptográficamente su solicitud con sus credenciales. Si no
utiliza las herramientas de AWS, debe firmar usted mismo la solicitud. Para ello, utilice Signature Version
4, un protocolo para autenticar solicitudes de API de entrada. Para obtener más información acerca de la
autenticación de solicitudes, consulte Proceso de firma Signature Version 4 en la AWS General Reference.
Independientemente del método de autenticación que utilice, es posible que también deba proporcionar
información de seguridad adicional. Por ejemplo, AWS le recomienda el uso de la autenticación multifactor
(MFA) para aumentar la seguridad de su cuenta. Para obtener más información, consulte Uso de Multi-
Factor Authentication (MFA) en AWS en la Guía del usuario de IAM.
Usuario raíz de la cuenta de AWS

Cuando se crea por primera vez una cuenta de AWS, se comienza con una única identidad de inicio de
sesión que tiene acceso completo a todos los servicios y recursos de AWS de la cuenta. Esta identidad
recibe el nombre de AWS de la cuenta de usuario raíz y se obtiene acceso a ella iniciando sesión con la
dirección de correo electrónico y la contraseña que utilizó para crear la cuenta. Le recomendamos que
no utilice usuario raíz en sus tareas cotidianas, ni siquiera en las tareas administrativas. En lugar de ello,
es mejor ceñirse a la práctica recomendada de utilizar exclusivamente usuario raíz para crear el primer
usuario de IAM. A continuación, guarde las credenciales de usuario raíz en un lugar seguro y utilícelas
únicamente para algunas tareas de administración de cuentas y servicios.
Usuarios y grupos de IAM

Un usuario de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos para una
sola persona o aplicación. Un usuario de IAM puede tener credenciales a largo plazo, como un nombre
de usuario y una contraseña o un conjunto de claves de acceso. Para obtener más información acerca de
cómo generar claves de acceso, consulte Administración de las claves de acceso de los usuarios de IAM
en la Guía del usuario de IAM. Al generar claves de acceso para un usuario de IAM, asegúrese de ver y
guardar de forma segura el par de claves. No puede recuperar la clave de acceso secreta en el futuro. En
su lugar, debe generar un nuevo par de claves de acceso.
Un grupo de IAM es una identidad que especifica un conjunto de usuarios de IAM. No puede iniciar sesión
como grupo. Puede usar los grupos para especificar permisos para varios usuarios a la vez. Los grupos
facilitan la administración de los permisos de grandes conjuntos de usuarios. Por ejemplo, podría tener un
grupo cuyo nombre fuese Administradores de IAM y conceder permisos a dicho grupo para administrar los
recursos de IAM.
Los usuarios son diferentes de los roles. Un usuario se asocia exclusivamente a una persona o aplicación,
pero la intención es que cualquier usuario pueda asumir un rol que necesite. Los usuarios tienen
credenciales permanentes a largo plazo y los roles proporcionan credenciales temporales. Para obtener
más información, consulte Cuándo crear un usuario de IAM (en lugar de un rol) en la Guía del usuario de
IAM.
Roles de IAM
Un rol de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos. Es similar a
un usuario de IAM, pero no está asociado a una determinada persona. Puede asumir temporalmente un
rol de IAM en la Consola de administración de AWS cambiando de roles. Puede asumir un rol llamando
a una operación de la AWS CLI o de la API de AWS, o utilizando una URL personalizada. Para obtener
más información acerca de los métodos para el uso de roles, consulte Uso de roles de IAM en la Guía del
usuario de IAM.
472
Administración de acceso mediante políticas
Los roles de IAM con credenciales temporales son útiles en las siguientes situaciones:
• Permisos de usuario temporales de IAM: un usuario de IAM puede asumir un rol de IAM para recibir
temporalmente permisos distintos que le permitan realizar una tarea concreta.
• Acceso de usuario federado: En lugar de crear un usuario de IAM, puede utilizar identidades existentes
de AWS Directory Service, del directorio de usuarios de la empresa o de un proveedor de identidades
web. A estas identidades se les llama usuarios federados. AWS asigna una función a un usuario
federado cuando se solicita acceso a través de un proveedor de identidad. Para obtener más
información acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía del
usuario de IAM.
• Acceso entre cuentas: puede utilizar un rol de IAM para permitir que alguien (una entidad principal de
confianza) de otra cuenta obtenga acceso a los recursos de su cuenta. Los roles son la forma principal
de conceder acceso entre cuentas. Sin embargo, con algunos servicios de AWS, puede asociar una
política directamente a un recurso (en lugar de utilizar un rol como proxy). Para obtener información
acerca de la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas,
consulte Cómo los roles de IAM difieren de las políticas basadas en recursos en la Guía del usuario de
IAM.
• Acceso a servicios de AWS: Un rol de servicio es un rol de IAM que un servicio asume para realizar
acciones en su cuenta en su nombre. Al configurar algunos de los entornos de los servicios de AWS,
debe definir un rol que el servicio asumirá. Este rol de servicio debe incluir todos los permisos que
son necesarios para que el servicio pueda acceder a los recursos de AWS que necesita. Los roles de
servicio varían de servicio a servicio, pero muchos le permiten elegir sus permisos, siempre y cuando
se cumplan los requisitos documentados para dicho servicio. Los roles de servicio ofrecen acceso solo
dentro de su cuenta y no se pueden utilizar para otorgar acceso a servicios en otras cuentas. Puede
crear, modificar y eliminar un rol de servicio desde IAM. Por ejemplo, puede crear un rol que permita
a Amazon Redshift tener acceso a un bucket de Amazon S3 en su nombre y, a continuación, cargar
los datos de ese bucket en un clúster de Amazon Redshift. Para obtener más información, consulte
Creación de un rol para delegar permisos a un servicio de AWS en la Guía del usuario de IAM.
• Aplicaciones que se ejecutan en Amazon EC2: Puede utilizar un rol de IAM para administrar
credenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizan
solicitudes de la AWS CLI o la API de AWS. Es preferible hacerlo de este modo a almacenar claves de
acceso en la instancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición de
todas las aplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene el
rol y permite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Para
obtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones que se
ejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.
Para obtener información acerca del uso de los roles de IAM, consulte Cuándo crear un rol de IAM (en vez
de un usuario) en la Guía del usuario de IAM.

Para controlar el acceso en AWS, se crean políticas y se asocian a identidades de IAM o recursos de
AWS. Una política es un objeto de AWS que, cuando se asocia a una identidad o un recurso, define
sus permisos. AWS evalúa estas políticas cuando una entidad principal (usuario raíz, usuario de IAM o
rol de IAM) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o se
deniega. Las mayoría de las políticas se almacenan en AWS como documentos JSON. Para obtener
más información acerca de la estructura y el contenido de los documentos de política JSON, consulte
Información general de las políticas de JSON en la Guía del usuario de IAM.
Un administrador de IAM puede utilizar las políticas para especificar quién tiene acceso a los recursos de
AWS y qué acciones se pueden realizar en dichos recursos. Cada entidad de IAM (usuario o rol) comienza
sin permisos. En otras palabras, de forma predeterminada, los usuarios no pueden hacer nada, ni siquiera
cambiar sus propias contraseñas. Para conceder permiso a un usuario para hacer algo, el administrador
debe asociarle una política de permisos. O bien el administrador puede añadir al usuario a un grupo que
473
tenga los permisos necesarios. Cuando el administrador concede permisos a un grupo, todos los usuarios
de ese grupo obtienen los permisos.
Las políticas de IAM definen permisos para una acción independientemente del método que se utilice
para realizar la operación. Por ejemplo, suponga que dispone de una política que permite la acción
iam:GetRole. Un usuario con dicha política puede obtener información del usuario de la Consola de
administración de AWS, la AWS CLI o la API de AWS.
Políticas basadas en identidad

Las políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociar
a una identidad, como por ejemplo un usuario, un rol o un grupo de IAM. Estas políticas controlan qué
acciones puede realizar dicha identidad, en qué recursos y en qué condiciones. Para obtener más
información acerca de cómo crear una política basada en identidad, consulte Creación de políticas de IAM
en la Guía del usuario de IAM.
Las políticas basadas en identidad pueden clasificarse además como políticas insertadas o políticas
administradas. Las políticas insertadas se integran directamente en un único usuario, grupo o rol. Las
políticas administradas son políticas independientes que puede asociar a varios usuarios, grupos y roles
de su cuenta de AWS. Las políticas administradas incluyen las políticas administradas por AWS y las
políticas administradas por el cliente. Para obtener más información acerca de cómo elegir una política
administrada o una política insertada, consulte Elegir entre políticas administradas y políticas insertadas en
la Guía del usuario de IAM.

Las políticas basadas en recursos son documentos de política JSON que puede asociar a un recurso
como, por ejemplo, un bucket de Amazon S3. Los administradores de servicios pueden utilizar estas
políticas para definir qué acciones puede realizar un principal especificado (miembro de cuenta, usuario o
rol) en dicho recurso y bajo qué condiciones. Las políticas basadas en recursos son políticas insertadas.
No existen políticas basadas en recursos que sean administradas.
Listas de control de acceso (ACL)

Las listas de control de acceso (ACL) son un tipo de política que controlan qué entidades principales
(cuentas, miembros, usuarios o roles) tienen permisos para obtener acceso a un recurso. Las ACL son
similares a las políticas basadas en recursos, aunque no utilizan el formato de documento de política
JSON. Amazon S3, AWS WAF y Amazon VPC son ejemplos de servicios que admiten ACL. Para obtener
más información sobre las ACL, consulte Información general de las Access Control Lists (ACL, Listas de
control de acceso) en la Guía para desarrolladores de Amazon Simple Storage Service.
Otros tipos de políticas

AWS admite otros tipos de políticas menos frecuentes. Estos tipos de políticas pueden establecer el
máximo de permisos que los tipos de políticas más frecuentes le otorgan.
• Límites de permisos: un límite de permisos es una característica avanzada que le permite definir los
permisos máximos que una política basada en identidad puede conceder a una entidad de IAM (usuario
o rol de IAM). Puede establecer un límite de permisos para una identidad. Los permisos resultantes son
la intersección de las políticas basadas en identidades de la entidad y los límites de sus permisos. Las
políticas basadas en recursos que especifiquen el usuario o rol en el campo Principal no estarán
restringidas por el límite de permisos. Una denegación explícita en cualquiera de estas políticas anulará
el permiso. Para obtener más información acerca de los límites de permisos, consulte see Límites de
permisos para las entidades de IAM en la Guía del usuario de IAM.
• Políticas de control de servicios (SCP): las SCP son políticas de JSON que especifican los permisos
máximos para una organización o unidad organizativa (OU) en AWS Organizations. AWS Organizations
es un servicio que le permite agrupar y administrar de forma centralizada varias cuentas de AWS
474
Cómo funciona AWS Lambda con IAM
que posee su negocio. Si habilita todas las funciones en una organización, entonces podrá aplicar
políticas de control de servicio (SCP) a una o todas sus cuentas. Una SCP limita los permisos para las
entidades de las cuentas de miembros, incluido cada Usuario de la cuenta raíz de AWS. Para obtener
más información acerca de Organizaciones y las SCP, consulte Funcionamiento de las SCP en la Guía
del usuario de AWS Organizations.
• Políticas de sesión: las políticas de sesión son políticas avanzadas que se pasan como parámetro
cuando se crea una sesión temporal mediante programación para un rol o un usuario federado. Los
permisos de la sesión resultantes son la intersección de las políticas basadas en identidades del rol y las
políticas de la sesión. Los permisos también pueden proceder de una política basada en recursos. Una
denegación explícita en cualquiera de estas políticas anulará el permiso. Para obtener más información,
consulte Políticas de sesión en la Guía del usuario de IAM.
Varios tipos de políticas

Cuando se aplican varios tipos de políticas a una solicitud, los permisos resultantes son más complicados
de entender. Para obtener información acerca de cómo AWS determina si permitir una solicitud cuando
hay varios tipos de políticas implicados, consulte Lógica de evaluación de políticas en la Guía del usuario
de IAM.
Cómo funciona AWS Lambda con IAM

Antes de utilizar IAM para administrar el acceso a Lambda, debe saber qué características de IAM están
disponibles para su uso con Lambda. Para obtener una perspectiva general de cómo funcionan Lambda y
otros servicios de AWS con IAM, consulte Servicios de AWS que funcionan con IAM en la Guía del usuario
de IAM.
Para obtener información general acerca de los permisos, las políticas y funciones a medida que Lambda
utiliza, consulte Permisos de AWS Lambda (p. 33).
Ejemplos de políticas basadas en identidades de AWS

Lambda
De forma predeterminada, los usuarios y roles de IAM no tienen permiso para crear, ver ni modificar
recursos de Lambda. Tampoco pueden realizar tareas mediante la Consola de administración de AWS, la
AWS CLI, o la API de AWS. Un administrador de IAM debe crear políticas de IAM que concedan permisos
a los usuarios y a los roles para realizar operaciones de la API concretas en los recursos especificados
que necesiten. El administrador debe adjuntar esas políticas a los usuarios o grupos de IAM que necesiten
esos permisos.
Para obtener más información acerca de cómo crear una política basada en identidad de IAM con estos
documentos de políticas de JSON de ejemplo, consulte Creación de políticas en la pestaña JSON en la
Guía del usuario de IAM.
Temas
• Prácticas recomendadas relativas a políticas (p. 475)
• Mediante la consola de Lambda (p. 476)
• Permitir a los usuarios consultar sus propios permisos (p. 476)
Prácticas recomendadas relativas a políticas

Las políticas basadas en identidad son muy eficaces. Determinan si alguien puede crear, acceder o
eliminar los recursos de Lambda de su cuenta. Estas acciones pueden generar costes adicionales para su
cuenta de AWS. Siga estas directrices y recomendaciones al crear o editar políticas basadas en identidad:
475
Ejemplos de políticas basadas en identidades
• Introducción sobre el uso de políticas administradas de AWS: para comenzar a utilizar Lambda
rápidamente, utilice las políticas administradas de AWS para proporcionar a los empleados los permisos
necesarios. Estas políticas ya están disponibles en su cuenta y las mantiene y actualiza AWS. Para
obtener más información, consulte Introducción sobre el uso de permisos con políticas administradas de
AWS en la Guía del usuario de IAM.
• Conceder privilegios mínimos: al crear políticas personalizadas, conceda solo los permisos necesarios
para llevar a cabo una tarea. Comience con un conjunto mínimo de permisos y conceda permisos
adicionales según sea necesario. Por lo general, es más seguro que comenzar con permisos que son
demasiado tolerantes e intentar hacerlos más severos más adelante. Para obtener más información,
consulte Conceder privilegios mínimos en la Guía del usuario de IAM.
• Habilitar MFA para operaciones confidenciales: para mayor seguridad, obligue a los usuarios de
IAM a que utilicen la autenticación multifactor (MFA) para acceder a recursos u operaciones de API
confidenciales. Para obtener más información, consulte Uso de Multi-Factor Authentication (MFA) en
AWS en la Guía del usuario de IAM.
• Utilizar condiciones de política para mayor seguridad: en la medida en que sea práctico, defina las
condiciones en las que sus políticas basadas en identidad permitan el acceso a un recurso. Por ejemplo,
puede escribir condiciones para especificar un rango de direcciones IP permitidas desde el que debe
proceder una solicitud. También puede escribir condiciones para permitir solicitudes solo en un intervalo
de hora o fecha especificado o para solicitar el uso de SSL o MFA. Para obtener más información,
consulte Elementos de la política de JSON de IAM: condición en la Guía del usuario de IAM.
Mediante la consola de Lambda

Para acceder a la consola de AWS Lambda, debe tener un conjunto mínimo de permisos. Estos permisos
deben permitirle registrar y consultar los detalles sobre los recursos de Lambda en su cuenta de AWS. Si
crea una política basada en identidad que sea más restrictiva que el mínimo de permisos necesarios, la
consola no funcionará del modo esperado para las entidades (usuarios o roles de IAM) que tengan esa
política.
Para obtener un ejemplo de política que concede un acceso mínimo para el desarrollo de funciones,
consulte Desarrollo de funciones (p. 42). Además de las API de Lambda, la consola de Lambda utiliza
otros servicios para mostrar la configuración de activación y permitir agregar nuevos desencadenadores.
Si sus usuarios usan Lambda con otros servicios, también necesitan acceso a esos servicios. Para obtener
más información sobre cómo configurar otros servicios con Lambda, consulte Utilización de AWS Lambda
con otros servicios (p. 163).
Permitir a los usuarios consultar sus propios permisos

En este ejemplo, se muestra cómo podría crear una política que permita a los usuarios de IAM ver las
políticas administradas e insertadas que se asocian a la identidad de sus usuarios. Esta política incluye
permisos para llevar a cabo esta acción en la consola o mediante programación con la AWS CLI o la API
de AWS.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
476
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
Solucionar problemas de identidad y acceso en AWS

Lambda
Utilice la información siguiente para diagnosticar y solucionar los problemas comunes que puedan surgir
cuando trabaje con Lambda e IAM.
Temas
• No tengo autorización para realizar una acción en Lambda (p. 477)
• No tengo autorización para realizar la operación iam:PassRole (p. 477)
• Quiero ver mis claves de acceso (p. 478)
• Soy administrador y deseo permitir que otros obtengan acceso a Lambda (p. 478)
• Deseo permitir a personas externas a mi cuenta de AWS el acceso a mis recursos de
Lambda (p. 478)
No tengo autorización para realizar una acción en Lambda

Si la Consola de administración de AWS le indica que no está autorizado para llevar a cabo una acción,
debe ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le
facilitó su nombre de usuario y contraseña.
En el siguiente ejemplo, el error se produce cuando el usuario de IAM, mateojackson intenta utilizar la
consola para ver detalles sobre una función, pero no tiene permisos lambda:GetFunction.
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform:

lambda:GetFunction on resource: my-function
En este caso, Mateo pide a su administrador que actualice sus políticas de forma que pueda obtener
acceso al recurso my-function mediante la acción lambda:GetFunction.
No tengo autorización para realizar la operación iam:PassRole

Si recibe un error que indica que no está autorizado para llevar a cabo la acción iam:PassRole, debe
ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le facilitó
su nombre de usuario y contraseña. Pida a la persona que actualice sus políticas de forma que pueda
transferir un rol a Lambda.
477
Algunos servicios de AWS le permiten transferir un rol existente a dicho servicio en lugar de crear un nuevo
rol de servicio o uno vinculado al servicio. Para ello, debe tener permisos para transferir el rol al servicio.
En el siguiente ejemplo, el error se produce cuando un usuario de IAM denominado marymajor intenta
utilizar la consola para realizar una acción en Lambda. Sin embargo, la acción requiere que el servicio
cuente con permisos otorgados por un rol de servicio. Mary no tiene permisos para transferir el rol al
servicio.
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
En este caso, Mary pide a su administrador que actualice sus políticas para que pueda realizar la acción
iam:PassRole.
Quiero ver mis claves de acceso

Después de crear sus claves de acceso de usuario de IAM, puede ver su ID de clave de acceso en
cualquier momento. Sin embargo, no puede volver a ver su clave de acceso secreta. Si pierde la clave de
acceso secreta, debe crear un nuevo par de claves de acceso.
Las claves de acceso se componen de dos partes: un ID de clave de acceso (por ejemplo,
AKIAIOSFODNN7EXAMPLE) y una clave de acceso secreta (por ejemplo, wJalrXUtnFEMI/K7MDENG/
bPxRfiCYEXAMPLEKEY). El ID de clave de acceso y la clave de acceso secreta se utilizan juntos, como un
nombre de usuario y contraseña, para autenticar sus solicitudes. Administre sus claves de acceso con el
mismo nivel de seguridad que para el nombre de usuario y la contraseña.
Important
No proporcione las claves de acceso a terceras personas, ni siquiera para que le ayuden a buscar
el ID de usuario canónico. Si lo hace, podría conceder a otra persona acceso permanente a su
cuenta.
Cuando cree un par de claves de acceso, se le pide que guarde el ID de clave de acceso y la clave de
acceso secreta en un lugar seguro. La clave de acceso secreta solo está disponible en el momento de su
creación. Si pierde la clave de acceso secreta, debe añadir nuevas claves de acceso a su usuario de IAM.
Puede tener un máximo de dos claves de acceso. Si ya cuenta con dos, debe eliminar un par de claves
antes de crear uno nuevo. Para ver las instrucciones, consulte Administración de las claves de acceso en
la Guía del usuario de IAM.
Soy administrador y deseo permitir que otros obtengan acceso a

Lambda
Para permitir que otros obtengan acceso a Lambda, debe crear una entidad de IAM (usuario o rol) para
la persona o aplicación que necesita acceso. Esta persona utilizará las credenciales de la entidad para
obtener acceso a AWS. A continuación, debe asociar una política a la entidad que le conceda los permisos
correctos en Lambda.
Para comenzar de inmediato, consulte Creación del primer grupo y usuario delegado de IAM en la Guía del
usuario de IAM.
Deseo permitir a personas externas a mi cuenta de AWS el

acceso a mis recursos de Lambda
Puede crear un rol que los usuarios de otras cuentas o las personas externas a la organización puedan
utilizar para acceder a sus recursos. Puede especificar una persona de confianza para que asuma el rol.
478
Validación de la conformidad
En el caso de los servicios que admitan las políticas basadas en recursos o las listas de control de acceso
(ACL), puede utilizar dichas políticas para conceder a las personas acceso a sus recursos.
Para obtener más información, consulte lo siguiente:
• Para obtener información acerca de si Lambda admite estas características, consulte Cómo funciona
AWS Lambda con IAM (p. 475).
• Para aprender cómo proporcionar acceso a sus recursos en cuentas de AWS de su propiedad, consulte
Proporcionar acceso a un usuario de IAM a otra cuenta de AWS de la que es propietario en la Guía del
usuario de IAM.
• Para obtener información acerca de cómo ofrecer acceso a sus recursos a cuentas de AWS de terceros,
consulte Proporcionar acceso a las cuentas de AWS propiedad de terceros en la Guía del usuario de
IAM.
• Para obtener información acerca de cómo ofrecer acceso a la identidad federada, consulte Proporcionar
acceso a usuarios autenticados externamente (identidad federada) en la Guía del usuario de IAM.
• Para obtener información acerca de la diferencia entre utilizar los roles y las políticas basadas en
recursos para el acceso entre cuentas, consulte Cómo los roles de IAM difieren de las políticas basadas
en recursos en la Guía del usuario de IAM.
Validación de la conformidad de AWS Lambda

Auditores externos evalúan la seguridad y la conformidad de AWS Lambda como parte de varios
programas de conformidad de AWS. Estos incluyen SOC, PCI, FedRAMP, HIPAA y otros.
Para obtener una lista de los servicios de AWS en el ámbito de programas de conformidad específicos,
consulte Servicios de AWS en el ámbito del programa de conformidad. Para obtener información general,
consulte Programas de conformidad de AWS.
Puede descargar los informes de auditoría de terceros utilizando AWS Artifact. Para obtener más
información, consulte Descarga de informes en AWS Artifact.
Su responsabilidad de conformidad al utilizar Lambda se determina en función de la sensibilidad de los

datos, los objetivos de cumplimiento de su empresa y la legislación y los reglamentos correspondientes.
AWS proporciona los siguientes recursos para ayudar con la conformidad:
• Guías de inicio rápido de seguridad y conformidad – estas guías de implementación tratan

consideraciones sobre arquitectura y ofrecen pasos para implementar los entornos de referencia
centrados en la seguridad y la conformidad en AWS.
• Documento técnico sobre arquitectura para seguridad y conformidad de HIPAA – este documento
técnico describe cómo las empresas pueden utilizar AWS para crear aplicaciones conformes con HIPAA.
• Recursos de conformidad de AWS – este conjunto de manuales y guías podría aplicarse a su sector y
ubicación.
• AWS Config – este servicio de AWS evalúa en qué medida las configuraciones de los recursos cumplen
las prácticas internas, las directrices del sector y las normativas.
• AWS Security Hub – Este servicio de AWS ofrece una vista integral de su estado de seguridad en
AWS que le ayuda a comprobar la conformidad con las normas del sector de seguridad y las prácticas
recomendadas.
Resiliencia de AWS Lambda

La infraestructura global de AWS está conformada por regiones y zonas de disponibilidad de AWS. Las
regiones de AWS proporcionan varias zonas de disponibilidad físicamente independientes y aisladas
479
Seguridad de la infraestructura
que se encuentran conectadas mediante redes con un alto nivel de rendimiento y redundancia, además
de baja latencia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datos
que realizan una conmutación por error automática entre zonas de disponibilidad sin interrupciones. Las
zonas de disponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las
infraestructuras tradicionales de centros de datos únicos o múltiples.
Para obtener más información sobre las zonas de disponibilidad y las regiones de AWS, consulte
Infraestructura global de AWS.
Además de la infraestructura global de AWS, Lambda ofrece varias características que le ayudan con sus
necesidades de resiliencia y copia de seguridad de los datos.
• Control de versiones: Puede utilizar el control de versiones en – Lambda para guardar el código de la
función y la configuración a medida que realice el desarrollo. Junto con los alias, puede utilizar el control
de versiones para realizar implementaciones continuas y blue/green. Para obtener más información,
consulte Versiones de funciones de AWS Lambda (p. 70).
• Escalado:: cuando la función recibe una solicitud mientras se procesa una solicitud anterior, Lambda
lanza otra instancia de su función para administrar el aumento de la carga. Lambda automáticamente
se escala para administrar ejecuciones simultáneas 1,000 por región, una cuota (p. 31) que se puede
aumentar si es necesario. Para obtener más información, consulte Escalado de funciones de AWS
Lambda (p. 114).
• Alta disponibilidad: – Lambda ejecuta la función en varias zonas de disponibilidad para asegurarse de
que está disponible para procesar eventos en caso de una interrupción del servicio en una sola zona.
Si configura la función para conectarse a una nube privada virtual (VPC) en su cuenta, especifique
subredes en varias zonas de disponibilidad para garantizar una alta disponibilidad. Para obtener más
información, consulte Configuración de una función de Lambda para obtener acceso a los recursos de
una VPC (p. 81).
• Simultaneidad reservada: – para asegurarse de que la función siempre puede escalarse para gestionar
solicitudes adicionales, puede reservar la simultaneidad para ella. Configurar la simultaneidad reservada
para una función garantiza que se puede escalar, pero no superar, un determinado número de
invocaciones simultáneas. De este modo, se asegura de que no pierde las solicitudes debido a otras
funciones que consumen toda la simultaneidad disponible. Para obtener más información, consulte
Administración de la simultaneidad para una función de Lambda (p. 62).
• Reintentos: en invocaciones asíncronas y un subconjunto de invocaciones activadas por otros servicios,
Lambda reintenta automáticamente en error con retrasos entre los reintentos. Otros clientes y servicios
de AWS que invocan de forma sincrónica son responsables de realizar los reintentos. Para obtener más
información, consulte Control de errores y reintentos automáticos en AWS Lambda (p. 119).
• Cola de mensajes fallidos: – en invocaciones asíncronas, puede configurar Lambda para enviar
solicitudes a una cola de mensajes fallidos si fallan todos los reintentos. Una cola de mensajes fallidos
es un tema de Amazon SNS o una cola de Amazon SQS que recibe eventos para la resolución de
problemas o para reprocesamiento. Para obtener más información, consulte Colas de mensajes fallidos
de funciones de AWS Lambda (p. 107).
Seguridad de la infraestructura en AWS Lambda

Como servicio administrado, AWS Lambda está protegido por los procedimientos de seguridad de red
globales de AWS que se describen en el documento técnico Amazon Web Services: Información general
sobre procesos de seguridad.
Puede utilizar llamadas a la API publicadas en AWS para obtener acceso a Lambda a través de la red.
Los clientes deben ser compatibles con Transport Layer Security (TLS) 1.0 o una versión posterior.
Le recomendamos TLS 1.2 o una versión posterior. Los clientes también deben ser compatibles con
conjuntos de cifrado con confidencialidad directa total (PFS) tales como Ephemeral Diffie-Hellman (DHE)
o Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). La mayoría de los sistemas modernos como Java 7 y
posteriores son compatibles con estos modos.
480
Configuración y análisis de vulnerabilidades
Además, las solicitudes deben estar firmadas mediante un ID de clave de acceso y una clave de acceso
secreta que esté asociada a una entidad principal de IAM. También puede utilizar AWS Security Token
Service (AWS STS) para generar credenciales de seguridad temporales para firmar solicitudes.
Configuración y análisis de vulnerabilidades en

AWS Lambda
AWS Lambda proporciona tiempos de ejecución (p. 130) que ejecutan su código de función en un entorno
de ejecución basado en Linux de Amazon.– Lambda es responsable de mantener el software en tiempo
de ejecución y el entorno de ejecución actualizado, publicando nuevos tiempos de ejecución para nuevos
lenguajes y marcos y dejará de proporcionar tiempos de ejecución cuando el software subyacente deje de
admitirse.
Si utiliza bibliotecas adicionales con su función, será responsable de actualizar las bibliotecas. Puede
incluir bibliotecas adicionales en el paquete de implementación (p. 22) o en capas (p. 76) que asocie
a su función. También puede crear tiempos de ejecución personalizados (p. 134) y utilizar capas para
compartirlas con otras cuentas.
Lambda descarta tiempos de ejecución cuando el software en el tiempo de ejecución o su entorno

de ejecución alcanza el final de su vida útil. Cuando Lambda descarta un tiempo de ejecución, será
responsable de migrar sus funciones a un tiempo de ejecución compatible para el mismo lenguaje o marco.
Para obtener más información, consulte Política de soporte del tiempo de ejecución (p. 132).
481
Implementación
Solución de problemas de AWS

Lambda
Los temas siguientes proporcionan consejos para solucionar problemas de errores y problemas que
puedan surgir al utilizar la API de Lambda, la consola o las herramientas. Si se encuentra con un problema
que no aparezca en esta lista, puede utilizar el botón Feedback (Comentarios) de esta página para
notificarlo.
Para obtener más consejos para la resolución de problemas y respuestas a preguntas comunes de
soporte, visite el Centro de conocimientos de AWS.
Temas
• Solución de problemas en las implementaciones de AWS Lambda (p. 482)
• Solucionar problemas de invocación en AWS Lambda (p. 484)
• Solucionar problemas de ejecución en AWS Lambda (p. 486)
• Solucionar problemas de redes en AWS Lambda (p. 488)
Solución de problemas en las implementaciones de

AWS Lambda
Al actualizar su función, Lambda implementa el cambio iniciando nuevas instancias de la función con el
código o la configuración actualizados. Los errores de implementación impiden que se utilice la nueva
versión y pueden deberse a problemas con el paquete de implementación, el código, los permisos o las
herramientas.
Cuando implementa actualizaciones en su función directamente con la API de Lambda o con un cliente
como la AWS CLI, puede ver errores de Lambda directamente en la salida. Si utiliza servicios como AWS
CloudFormation, AWS CodeDeploy o AWS CodePipeline, busque la respuesta de Lambda en los registros
o en la secuencia de eventos del servicio.
Error: EACCES: permission denied, open '/var/task/index.js'
Error: cannot load such file -- function
Error: [Errno 13] Permission denied: '/var/task/function.py'
El runtime de Lambda necesita permiso para leer los archivos del paquete de implementación. Puede
utilizar el comando chmod para cambiar el modo de archivo. Los siguientes comandos de ejemplo permiten
que cualquier usuario pueda leer todos los archivos y carpetas del directorio actual.
my-function$ chmod 644 $(find . -type f)

my-function$ chmod 755 $(find . -type d)
Error: An error occurred (RequestEntityTooLargeException) when calling the UpdateFunctionCode

operation
482
Implementación
Cuando carga un paquete de implementación o un archivo de capa directamente en Lambda, el tamaño

del archivo ZIP está limitado a 50 MB. Para cargar un archivo más grande, almacénelo en Amazon S3 y
utilice los parámetros S3Bucket y S3Key (p. 660) .
Note
Cuando carga un archivo directamente con la AWS CLI, el SDK de AWS o de otro modo, el
archivo ZIP binario se convierte a base64, que aumenta su tamaño en aproximadamente un 30 %.
Para permitir esto y el tamaño de otros parámetros de la solicitud, el límite de tamaño de solicitud
real que aplica Lambda es mayor. Por este motivo, el límite de 50 MB es aproximado.
Error: se produjo un error mientras GetObject. Código de error S3: PermanentRedirect. Mensaje de error
S3: el bucket está en esta región: us-east-2. Utilice esta región para volver a intentar la solicitud
Cuando carga el paquete de implementación de una función desde un bucket Amazon S3, el bucket
debe estar en la misma Región que la función. Este problema puede producirse cuando especifica un
Amazon S3 objeto en una llamada a UpdateFunctionCode (p. 659), o utiliza el paquete y los comandos
de implementación en la CLI de AWS o en la CLI de AWS SAM. Cree un depósito de artefactos de
implementación para cada Región donde desarrolle aplicaciones.
Error: Cannot find module 'function'
Error: cannot load such file -- function
Error: Unable to import module 'function'
Error: Class not found: function.Handler
Error: fork/exec /var/task/function: no such file or directory
Error: Unable to load type 'Function.Handler' from assembly 'Function'.
El nombre del archivo o clase en la configuración del controlador de su función no coincide con su código.
Consulte la siguiente entrada para obtener más información.
Error: index.handler is undefined or not exported
Error: Handler 'handler' missing on module 'function'
Error: undefined method `handler' for #<LambdaHandler:0x000055b76ccebf98>
Error: No public method named handleRequest with appropriate method signature found on class class
function.Handler
Error: Unable to find method 'handleRequest' in type 'Function.Handler' from assembly 'Function'
El nombre del método de controlador en la configuración del controlador de su función no coincide con su
código. Cada motor de ejecución define una convención de nomenclatura para los controladores, como
nombredearchivo.nombredelmétodo. El controlador es el método en el código de su función ejecutado
por el tiempo de ejecución cuando se invoca la función.
En algunos idiomas, Lambda proporciona una biblioteca con una interfaz que espera que un método de
controlador tenga un nombre específico. Para obtener información detallada sobre la nomenclatura de
controladores para cada idioma, consulte los temas siguientes.
• Creación de funciones de Lambda con Node.js (p. 332)

• Creación de funciones de Lambda con Python (p. 349)
• Creación de funciones de Lambda con Ruby (p. 367)
483
Invocación

Error: InvalidParameterValueException: Lambda no pudo configurar las variables de entorno porque

las variables de entorno que ha proporcionado han excedido el límite de 4 KB. Cadena medida:
{"A1":"uSFeY5cyPiPn7AtnX5BsM...
Error: RequestEntityTooLargeException: la solicitud debe ser menor de 5120 bytes para la operación
UpdateFunctionConfiguration
El tamaño máximo del objeto de variables que se almacena en la configuración de la función no debe
exceder los 4096 bytes. Esto incluye nombres clave, valores, comillas, comas y corchetes. El tamaño total
del cuerpo de la solicitud HTTP también es limitado.
{
"Environment": {
"Variables": {
"BUCKET": "my-bucket",
"KEY": "file.txt"
}
},
...
}
En este ejemplo, el objeto tiene 39 caracteres y ocupa 39 bytes cuando se almacena (sin espacios en
blanco) como la cadena {"BUCKET":"my-bucket","KEY":"file.txt"}. Los caracteres ASCII
estándar en valores de variables de entorno utilizan un byte cada uno. Los caracteres ASCII y Unicode
extendidos pueden usar entre 2 y 4 bytes por carácter.
Error: InvalidParameterValueException: Lambda no pudo configurar las variables de entorno porque las
variables de entorno que ha proporcionado contienen claves reservadas que actualmente no se admiten
para su modificación.
Lambda reserva algunas claves de variables de entorno para uso interno. Por ejemplo, el motor de
ejecución usa AWS_REGION para determinar la región actual y no se puede reemplazar. Otras variables,
como PATH, son usadas por el tiempo de ejecución, pero se pueden extender en la configuración de su
función. Para obtener una lista completa, consulte Variables de entorno de tiempo de ejecución (p. 58).
Solucionar problemas de invocación en AWS

Lambda
Cuando invoca una función de Lambda, Lambda valida la solicitud y comprueba la capacidad de escalado
antes de enviar el evento a su función o, para la invocación asíncrona, a la cola de eventos. Los errores
de invocación pueden deberse a problemas con los parámetros de solicitud, la estructura de eventos, la
configuración de funciones, los permisos de usuario, los permisos de recursos o los límites.
Si invoca su función directamente, verá errores de invocación en la respuesta de Lambda. Si invoca

la función de forma asíncrona, con una asignación de origen de eventos o a través de otro servicio, es
posible que encuentre errores en los registros, una cola de mensajes fallidos o un destino de evento fallido.
Las opciones de manejo de errores y el comportamiento de reintento varían en función de cómo invoque
su función y del tipo de error.
484
Invocación
Para obtener una lista de los tipos de error que puede devolver la operación Invoke, consulte
Invoke (p. 587).
Error: User: arn:aws:iam::123456789012:user/developer is not authorized to perform:

lambda:InvokeFunction on resource: my-function
El usuario de IAM, o el rol que asume el usuario, necesita permiso para invocar una función. Este
requisito también se aplica a las funciones Lambda y a otros recursos informáticos que invocan funciones.
Añada la política administrada AWSLambdaRole o una política personalizada que permita la acción
lambda:InvokeFunction en la función de destino al usuario de IAM.
Note
A diferencia de otras acciones de la API en Lambda, el nombre de la acción en IAM

(lambda:InvokeFunction) no coincide con el nombre de la acción de la API (Invoke) para
invocar una función.
Para obtener más información, consulte Permisos de AWS Lambda (p. 33).
Error: ResourceConflictException: la operación no se puede realizar en este momento. La función se

encuentra actualmente en el siguiente estado: Pendiente
Cuando conecta una función a una VPC en el momento de la creación, la función entra en un estado
Pending mientras Lambda crea interfaces de red elásticas. Durante este tiempo, no puede invocar o
modificar su función. Si conecta su función a una VPC después de la creación, puede invocarla mientras la
actualización esté pendiente, pero no podrá modificar su código o configuración.
Para obtener más información, consulte Monitorización del estado de una función con la API de
Lambda (p. 113).
Error: una función está bloqueada en el estado Pending durante varios minutos.
Si una función queda bloqueada en el estado Pending durante más de seis minutos, llame a una de las
siguientes operaciones de API para desbloquearla.

Lambda cancela la operación pendiente y pone la función en el estado Failed. A continuación, puede
eliminar la función y volver a crearla, o bien intentar otra actualización.
Problema: Una función está usando toda la concurrencia disponible, causando que otras funciones se
limiten.
Para dividir la concurrencia disponible en una región en grupos, utilice concurrencia reservada (p. 62). La
concurrencia reservada garantiza que una función siempre puede escalar a su concurrencia asignada, y
también que no escalará más allá de su concurrencia asignada.
Problema: puede invocar la función directamente, pero esta no se ejecuta cuando otro servicio o cuenta la
invoca.
Puede conceder permisos a otros servicios (p. 163) y cuentas para invocar una función en la política
basada en recursos (p. 37) de la función. Si el usuario que invoca la función está en otra cuenta, ese
usuario también necesita permiso para invocar funciones (p. 42).
Problema: la función se invoca continuamente en bucle.
Esto suele ocurrir cuando la función administra recursos en el mismo servicio de AWS que lo activa. Por
ejemplo, es posible crear una función que almacene un objeto en un bucket de Amazon S3 configurado
485
Ejecución
con una notificación que invoca la función de nuevo (p. 272). Para detener la ejecución de la función, elija
Throttle (Restricción) en la página de configuración de la función (p. 54). A continuación, identifique la ruta
de acceso del código o el error de configuración que provocó la invocación recursiva.
Error: KMSDisabledException: Lambda no pudo descifrar las variables de entorno porque la clave KMS
utilizada está deshabilitada. Compruebe la configuración de teclas KMS de la función.
Este error puede producirse si su clave KMS está deshabilitada o si se revoca la concesión que permite
a Lambda usar la clave. Si falta la concesión, configure la función para usar una clave diferente. A
continuación, reasigne la clave personalizada para volver a crear la concesión.
Error: EFSMountFailureException: la función no pudo montar el sistema de archivos de EFS con el punto
de acceso arn:aws:elasticfilesystem:us-east-2:123456789012:access-point/fsap-015cxmplb72b405fd.
Se rechazó la solicitud de montaje en el sistema de archivos (p. 91) de la función. Compruebe los permisos
de la función y confirme que su sistema de archivos y su punto de acceso existen y están listos para su
uso.
Error: EFSMountConnectivityException: la función no se pudo conectar al sistema de archivos de

Amazon EFS con el punto de acceso arn:aws:elasticfilesystem:us-east-2:123456789012:access-point/
fsap-015cxmplb72b405fd. Compruebe la configuración de la red y vuelva a intentarlo.
La función no pudo establecer una conexión con el sistema de archivos (p. 91) de la función con el
protocolo NFS (puerto TCP 2049). Compruebe el grupo de seguridad y la configuración de enrutamiento de
las subredes de la VPC.
Error: EFSMountTimeoutException: la función no pudo montar el sistema de archivos EFS con el punto de
acceso {arn:aws:elasticfilesystem:us-east-2:123456789012:access-point/fsap-015cxmplb72b405fd} debido
a que se agotó el tiempo de espera del montaje
La función pudo conectarse al sistema de archivos (p. 91) de la función, pero se agotó el tiempo de
espera de la operación de montaje. Vuelva a intentarlo después en un tiempo corto y considere limitar la
concurrencia (p. 62) de la función para reducir la carga en el sistema de archivos.
Error: EFSIOException: esta instancia de función se detuvo porque Lambda detectó un proceso de E/S que
estaba tardando demasiado.
Se agotó el tiempo de espera de una invocación anterior y Lambda no pudo finalizar el controlador de
funciones. Este problema puede producirse cuando un sistema de archivos adjunto se queda sin créditos
de ráfaga y el rendimiento previsto es insuficiente. Para aumentar el rendimiento, puede aumentar el
tamaño del sistema de archivos o utilizar el rendimiento aprovisionado. Para obtener más información,
consulte Rendimiento (p. 246).
Solucionar problemas de ejecución en AWS

Lambda
Cuando el motor de ejecución de Lambda ejecuta el código de función, es posible que el evento se
procese en una instancia de la función que ha estado procesando eventos durante algún tiempo, o que
requiera que se inicialice una nueva instancia. Pueden producirse errores cuando durante la inicialización
de la función, cuando el código de controlador procesa el evento o cuando la función devuelve (o no
devuelve) una respuesta.
Los errores de ejecución de funciones pueden deberse a problemas con el código, la configuración de
funciones, los recursos descendentes o los permisos. Si invoca su función directamente, verá errores
de función en la respuesta de Lambda. Si invoca la función de forma asíncrona, con una asignación de
origen de eventos o a través de otro servicio, es posible que encuentre errores en los registros, una cola de
486
Ejecución
mensajes fallidos o un destino en caso de error. Las opciones de manejo de errores y el comportamiento
de reintento varían en función de cómo invoque su función y del tipo de error.
Cuando el código de función o el tiempo de ejecución de Lambda devuelven un error, el código de estado
en la respuesta de Lambda es 200 OK. La presencia de un error en la respuesta se indica mediante un
encabezado llamado X-Amz-Function-Error. Los códigos de estado de las series 400 y 500 están
reservados para los errores de invocación (p. 484).
Problema: la ejecución de la función tarda demasiado tiempo.
Si el código tarda mucho más en ejecutarse en Lambda que en el equipo local, puede estar limitado por
la memoria o la potencia de procesamiento disponibles para la función. Configure la función con memoria
adicional (p. 54) para aumentar la memoria y la CPU.
Problema: los registros no aparecen en CloudWatch Logs.
Problema: los registros de seguimiento no aparecen en AWS X-Ray.
La función necesita permiso para llamar a CloudWatch Logs y X-Ray. Actualice su rol de ejecución (p. 33)
para concederle permiso. Añada las siguientes políticas administradas para habilitar los registros y el
seguimiento.
• AWSLambdaBasicExecutionRole
• AWSXRayDaemonWriteAccess
Cuando añade permisos a su función, actualice también su código o configuración. Esto obliga a las
instancias en ejecución de su función, cuyas credenciales han expirado, a detenerse y ser sustituidas.
Problema: (Node.js) La función se devuelve antes de que el código termine de ejecutarse
Muchas bibliotecas, incluida la SDK de AWS, funcionan de forma asíncrona. Cuando realiza una llamada
de red o realiza otra operación que requiere esperar una respuesta, las bibliotecas devuelven un objeto
denominado promesa que realiza un seguimiento del progreso de la operación en segundo plano.
Para esperar a que la promesa se resuelva en una respuesta, utilice la palabra clave await. Esto bloquea
la ejecución de su código de controlador hasta que la promesa se resuelve en un objeto que contiene
la respuesta. Si no necesita usar los datos de la respuesta en su código, puede devolver la promesa
directamente al tiempo de ejecución.
Algunas bibliotecas no devuelven promesas, pero se pueden envolver en código que sí lo hace. Para
obtener más información, consulte Controlador de la función AWS Lambda en Node.js (p. 334).
Problema: El SDK de AWS incluido en el tiempo de ejecución no es la versión más reciente
Problema: El SDK de AWS incluido en el tiempo de ejecución se actualiza automáticamente
Los tiempos de ejecución de los lenguajes de scripting incluyen AWS SDK y se actualizan periódicamente
a la versión más reciente. La versión actual de cada motor de ejecución se muestra en la página de
tiempos de ejecución (p. 130). Para utilizar una versión más reciente del SDK de AWS o para bloquear las
funciones a una versión específica, puede agrupar la biblioteca con el código de función o crear una capa
de Lambda (p. 76). Para obtener información detallada sobre la creación de un paquete de implementación
con dependencias, consulte los temas siguientes:

487
Redes

Problema: (Python) Algunas bibliotecas no se cargan correctamente desde el paquete de implementación
Las bibliotecas con módulos de extensión escritos en C o C++ deben compilarse en un entorno con la
misma arquitectura de procesador que Lambda (Amazon Linux). Para obtener más información, consulte
Solucionar problemas de redes en AWS Lambda

De forma predeterminada, Lambda ejecuta sus funciones en una nube privada virtual (VPC) interna con
conectividad a los servicios de AWS e Internet. Para acceder a los recursos de red local, puede configurar
la función para que se conecte a una VPC de la cuenta (p. 81). Cuando utiliza esta característica,
administra el acceso a Internet y la conectividad de red de la función con recursos de VPC.
Los errores de conectividad de red pueden deberse a problemas de configuración de enrutamiento, reglas
de grupo de seguridad, permisos de rol, traducción de direcciones de red o disponibilidad de recursos
como direcciones IP o interfaces de red. Pueden dar lugar a un error específico o, si una solicitud no puede
alcanzar su destino, a un tiempo de espera.
Problema: La función pierde el acceso a Internet después de conectarse a una VPC
Error: Error: Connect ETIMEDOUT 176.32.98.189:443
Error: Error: Tiempo de espera de la tarea agotado tras 10,00 segundos
Cuando conecta una función a una VPC, todas las solicitudes salientes pasan por la VPC. Para conectarse
a Internet, configure la VPC para que envíe tráfico saliente desde la subred de la función a una puerta de
enlace NAT en una subred pública. Para obtener más información y ejemplos de configuraciones de VPC,
consulte Acceso a Internet y a los servicios para funciones conectadas a la VPC (p. 87).
Problema: La función necesita acceso a los servicios de AWS sin utilizar internet
Para conectarse a servicios de AWS desde una subred privada sin acceso a Internet, utilice los puntos de
enlace de la VPC. Para obtener una plantilla de ejemplo con extremos de VPC para DynamoDB y Amazon
S3, consulte ??? (p. 87).
Error: ENILimitReacedException: Se alcanzó el límite de interfaz de red elástica para la VPC de la función.
Al conectar una función a una VPC, Lambda crea una interfaz de red elástica para cada combinación
de subred y grupo de seguridad asociados a la función. Estas interfaces de red están limitadas a 250
por VPC, pero este límite puede aumentarse. Para solicitar un aumento, utilice la consola del Centro de
soporte.
488
Versiones de AWS Lambda

En la siguiente tabla, se describen los cambios importantes que se han realizado en la Guía para
desarrolladores de AWS Lambda desde mayo de 2018. Para obtener notificaciones sobre las
actualizaciones de esta documentación, suscríbase a la fuente RSS.
update-history-change update-history-description update-history-date
Claves de condición de IAM para Ahora puede usar claves de August 10, 2020
la configuración de Amazon VPC condición específicas de Lambda
para la configuración de VPC.
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. Para obtener
más información, consulte
Configuración de VPC para
funciones de IAM.
Configuración de concurrencia Ahora puede usar la siguiente July 7, 2020

para consumidores de configuración de concurrencia
secuencias Kinesis HTTP/2 para consumidores de Kinesis
con distribución ramificada
mejorada (secuencias
HTTP/2): ParallelizationFactor,
MaximumRetryAttempts,
MaximumRecordAgeInSeconds,
DestinationConfig y
BisectBatchOnFunctionError.
Para obtener más información,
consulte Uso de AWS Lambda
con Amazon Kinesis.
Ventana por lotes para Ahora puede configurar June 18, 2020
consumidores de secuencias una ventana por lotes
HTTP/2 de Kinesis (MaximumBatchingWindowInSeconds)
para secuencias HTTP/2.
Lambda lee los registros de
la secuencia hasta que haya
recopilado un lote completo o
hasta que caduque la ventana
del lote. Para obtener más
información, consulte Uso de
AWS Lambda con Amazon
Kinesis.
Compatibilidad para sistemas de Ahora puede conectar un sistema June 16, 2020
archivos de Amazon EFS de archivos de Amazon EFS
a sus funciones Lambda para
acceder a archivos de red
compartidos. Para obtener
489

Configuración del acceso al
sistema de archivos para las
funciones de Lambda.
Aplicaciones de ejemplo de La consola de Lambda ahora June 1, 2020

CDK de AWS en la consola de incluye aplicaciones de ejemplo
Lambda que utilizan Kit de desarrollo de
la nube de AWS (AWS CDK)
para TypeScript. El AWS CDK es
un marco que le permite definir
los recursos de su aplicación
en TypeScript, Python, Java
o .NET. Para obtener una
explicación sobre la creación de
aplicaciones, consulte Creación
de una aplicación con entrega
continua en la consola de
Lambda.
Compatibilidad con el tiempo de AWS Lambda ahora admite el March 31, 2020
ejecución de .NET Core 3.1.0 en tiempo de ejecución de .NET
AWS Lambda Core 3.1.0. Para obtener más
información, consulte .NET Core
CLI.
Compatibilidad con las API HTTP Se ha actualizado y ampliado la March 23, 2020
de API Gateway documentación sobre el uso de
Lambda con API Gateway, como
la compatibilidad con las API
HTTP. Se ha incorporado una
aplicación de ejemplo que crea
una API y una función con AWS
CloudFormation. Para obtener
más información, consulte Uso
de AWS Lambda con Amazon
API Gateway.
Ruby 2.7 Hay un nuevo tiempo de February 19, 2020

ejecución disponible para Ruby
2.7, ruby2.7, que es el primer
tiempo de ejecución de Ruby
al usar Amazon Linux 2. Para
obtener más información,
consulte Creación de funciones
Lambda con Ruby.
490
Métricas de simultaneidad Ahora AWS Lambda February 18, 2020

informa de la métrica
ConcurrentExecutions
para todas las funciones, alias y
versiones. Puede ver un gráfico
para esta métrica en la página
de supervisión de su función.
Anteriormente, sólo se informó
de ConcurrentExecutions
en el nivel de cuenta y para
las funciones que utilizan
concurrencia reservada. Para
obtener más detalles, consulte
Métricas de función de AWS
Lambda.
Actualizar a estados de función Los estados de función se January 24, 2020

aplican ahora para todas
las funciones de forma
predeterminada. Al conectar
una función a una VPC, Lambda
crea interfaces de red elásticas
compartidas. Esto permite que
su función se escale sin crear
interfaces de red adicionales.
Durante este tiempo, no puede
realizar operaciones adicionales
en la función, incluida la
actualización de su configuración
y la publicación de versiones.
En algunos casos, la invocación
también se ve afectada. Los
detalles sobre el estado actual de
una función están disponibles en
la API de Lambda.
Esta actualización se está

publicando en fases. Para
consulte el ciclo de vida
actualizado de los estados de
Lambda para redes de VPC en
el blog de informática de AWS.
Para obtener más información
acerca de los estados, consulte
Estados de función de AWS
Lambda.
491
Actualizaciones a la salida Se han agregado códigos de January 20, 2020

de la API de configuración de motivo a StateReasOnCode
funciones (InvalidSubnet,
InvalidSecurityGroup) y
LastUpdateStatusReasonCode
(SubNetOutOutOFIPAddresses,
InvalidSubnet,
InvalidSecurityGroup) para las
funciones que se conectan a
una VPC. Para obtener más
información acerca de los
estados, consulte Estados de
función de AWS Lambda.
Simultaneidad aprovisionada Ahora puede asignar December 3, 2019

simultaneidad aprovisionada para
una versión o alias de función.
La simultaneidad aprovisionada
permite que una función escale
sin fluctuaciones en la latencia.
Para obtener más detalles,
consulte Administración de la
simultaneidad de una función
Lambda.
Crear un proxy de base de datos Ahora puede usar la consola December 3, 2019
de Lambda para crear un proxy
de base de datos para una
función Lambda. Un proxy de
base de datos permite que una
función alcance altos niveles
de simultaneidad sin agotar las
conexiones de base de datos.
consulte Configuración del
acceso a la base de datos para
una función Lambda.
Compatibilidad con percentiles Ahora puede filtrar la métrica November 26, 2019
para la métrica de duración de duración en función de los
percentiles. Para obtener más
información, consulte Métricas de
AWS Lambda.
Opciones de gestión de errores Hay disponibles nuevas opciones November 25, 2019
para la invocación asincrónica de configuración para la
invocación asincrónica. Puede
configurar Lambda para limitar
los reintentos y establecer una
antigüedad de evento máxima.
consulte Configuración de
la gestión de errores para la
invocación asincrónica.
492
Gestión de errores para orígenes Hay disponibles nuevas opciones November 25, 2019
de eventos de flujo de configuración para los
mapeos de origen de eventos
que se leen de los flujos. Puede
configurar los mapeos de
orígenes de eventos de flujos
de DynamoDB y de flujos de
Kinesis para limitar los reintentos
y establecer una antigüedad
de registro máxima. Cuando
se producen errores, puede
configurar el mapeo de origen de
eventos para que divida los lotes
antes de volver a intentarlo y
envíe registros de invocación de
los lotes con error a una cola o
tema. Para obtener más detalles,
consulte Mapeo de orígenes de
eventos de AWS Lambda.
Estados de función Al crear o actualizar una función, November 25, 2019

esta cambia a un estado
pendiente mientras Lambda
aprovisiona recursos para
admitirla. Si conecta su función
a una VPC, Lambda puede
crear una interfaz de red elástica
compartida de inmediato, en
lugar de crear interfaces de red
cuando se invoca la función.
Esto da como resultado un mejor
rendimiento para las funciones
conectadas a la VPC, pero podría
requerir una actualización de la
automatización. Para obtener
más detalles, consulte Estados
de función de AWS Lambda.
Destinos para invocación Ahora puede configurar Lambda November 25, 2019
asincrónica para que envíe registros de
invocaciones asincrónicas a
otro servicio. Los registros de
invocación contienen detalles
sobre el evento, el contexto y la
respuesta de la función. Puede
enviar registros de invocación
a una cola SQS, un tema SNS,
una función Lambda o un bus
de eventos de EventBridge.
consulte Configuración de
destinos para invocación
asincrónica.
493
Aumento de la simultaneidad Una nueva opción para mapeos November 25, 2019
para orígenes de eventos de flujo de orígenes de eventos de flujos
de DynamoDB y de flujos de
Kinesis le permiten procesar
más de un lote a la vez de cada
fragmento. Cuando aumenta el
número de lotes simultáneos
por fragmento, la simultaneidad
de su función puede ser hasta
diez veces mayor que el número
de fragmentos en el flujo. Para
obtener más detalles, consulte
Mapeo de orígenes de eventos
de AWS Lambda.
Nuevos tiempos de ejecución Hay nuevos tiempos de ejecución November 18, 2019
para Node.js, Python y Java disponibles para Node.js 12,
Python 3.8 y Java 11. Para
consulte Tiempos de ejecución
de AWS Lambda.
Compatibilidad de la cola FIFO Ahora puede crear un mapeo November 18, 2019
con los orígenes de eventos de de orígenes de eventos que
Amazon SQS haga lecturas desde una cola
de primero en entrar, primero
en salir (FIFO). Antes, solo
se admitían colas estándar.
consulte Uso de AWS Lambda
con Amazon SQS.
Creación de aplicaciones en la La creación de aplicaciones en October 31, 2019

consola de Lambda la consola de Lambda ya está
disponible en general. Para
obtener instrucciones, consulte
Creación de una aplicación con
entrega continua en la consola
de Lambda.
494
Creación de aplicaciones en la Ahora puede crear una aplicación October 3, 2019

consola de Lambda (beta) de Lambda con una canalización
de entrega continua integrada
en la consola de Lambda. La
consola proporciona aplicaciones
de ejemplo que puede utilizar
como punto de partida para su
propio proyecto. Elija entre AWS
CodeCommit y GitHub para
el control de origen. Cada vez
que se introducen cambios en
el repositorio, la canalización
incluida se genera e implementa
automáticamente. Para obtener
instrucciones, consulte Creación
de una aplicación con entrega
continua en la consola de
Lambda.
Mejoras de rendimiento para Lambda utiliza ahora un nuevo September 3, 2019

funciones conectadas a una VPC tipo de interfaz de red elástica
que comparten todas las
funciones en una subred de
nube virtual privada (VPC). Al
conectar una función a una VPC,
Lambda crea una interfaz de
red para cada combinación de
grupo de seguridad y subred
que elija. Cuando las interfaces
de red compartidas están
disponibles, la función ya no
tiene que crear interfaces de red
adicionales conforme se escala.
Esto mejora drásticamente los
tiempos de inicio. Para obtener
Configuración de una función
Lambda para obtener acceso a
los recursos en una VPC.
Configuración de lotes de Ahora puede configurar una August 29, 2019

transmisión ventana de lote para las
asignaciones de orígenes de
eventos de Amazon DynamoDB
y Amazon Kinesis. Puede
configurar una ventana de
lote de hasta cinco minutos
para almacenar los registros
entrantes hasta completar un
lote. Esto reduce el número de
invocaciones a la función cuando
el flujo se encuentra menos
activo.
495
Integración de la información de La página de monitorización de la June 18, 2019

CloudWatch Logs consola de Lambda ahora incluye
informes de Amazon CloudWatch
Logs Insights. Para obtener más
información, consulte Funciones
de monitorización en la consola
de AWS Lambda.
Amazon Linux 2018.03 El entorno de ejecución de May 21, 2019

Lambda se está actualizando
para utilizar Amazon Linux
2018.03. Para obtener más
información, consulte Entorno de
ejecución.
Node.js Hay un nuevo runtime disponible May 13, 2019

para Node.js 10, nodejs10.x.
Este runtime utiliza Node.js 10.15
y se actualizará con la última
versión secundaria de Node.js
10 periódicamente. Node.js 10
es también el primer runtime
que utiliza Amazon Linux 2.
Lambda con Node.js.
GetLayerVersionByArn API Utilice la API April 25, 2019

GetLayerVersionByArn
para descargar información
de la versión de capa con
el ARN de versión como
entrada. En comparación
con GetLayerVersion,
GetLayerVersionByArn le permite
utilizar el ARN directamente en
lugar de analizarlo para obtener
el nombre de la capa y el número
de versión.
Runtimes personalizados Cree un tiempo de ejecución November 29, 2018

personalizado para ejecutar
funciones de Lambda en su
lenguaje de programación
preferido. Para obtener más
información, consulte Tiempos
de ejecución de AWS Lambda
personalizados.
Ruby AWS Lambda ahora admite November 29, 2018

Ruby 2.5 con un nuevo runtime.
Lambda con Ruby.
496
Desencadenadores de Elastic Load Balancing ahora November 29, 2018

balanceadores de carga de es compatible con funciones
aplicaciones Lambda como destino de
Application Load Balancers.
consulte Uso de Lambda con
balanceadores de carga de
aplicaciones.
Capas Con las capas de Lambda, puede November 29, 2018

empaquetar e implementar
bibliotecas, tiempos de
ejecución personalizados y
otras dependencias de forma
independiente del código de la
función. Comparta sus capas
con sus otras cuentas o todo
el mundo. Para obtener más
información, consulte Capas de
AWS Lambda.
Uso de los consumidores de Puede utilizar los consumidores November 19, 2018
flujos HTTP/2 de Kinesis como de flujos de datos HTTP/2 de
desencadenadores Kinesis para enviar eventos a
AWS Lambda. Los consumidores
de flujos tienen rendimiento de
lectura dedicado desde cada
partición del flujo de datos y
utilizan HTTP/2 para minimizar
la latencia. Para obtener más
información, consulte Uso de
AWS Lambda con Kinesis.
Python 3.7 AWS Lambda ahora es November 19, 2018

compatible con Python 3.7 con
un nuevo tiempo de ejecución.
Lambda con Python.
Incremento del límite de carga El tamaño de carga máximo para November 16, 2018
para las invocaciones asíncronas las invocaciones asíncronas
de funciones ha aumentado de 128 KB a
256 KB, que coincide con el
tamaño máximo del mensaje
desde un desencadenador de
Amazon SNS. Para obtener
detalles, consulte Cuotas de
AWS Lambda.
Región AWS GovCloud (EE. UU. AWS Lambda ya está disponible November 12, 2018
Este) en la región AWS GovCloud
(EE.UU. Este). Para obtener
más información, consulte AWS
GovCloud (EE. UU. Este). now
open en el blog de AWS.
497
Contenido trasladado a la nueva Algunos contenidos se centraban October 25, 2018

Guía para desarrolladores de en la creación de aplicaciones
AWS SAM. sin servidor usando el Modelo de
aplicación sin servidor de AWS
(AWS SAM). Estos contenidos
se han trasladado a Guía para
desarrolladores de Modelo de
aplicación sin servidor de AWS.
Visualización de aplicaciones de Puede ver el estado de sus October 11, 2018

Lambda en la consola aplicaciones de Lambda
en la página Applications
(Aplicaciones) en la consola de
Lambda. Esta página muestra
el estado de la pila de AWS
CloudFormation. Incluye enlaces
a páginas donde puede ver
más información acerca de los
recursos de la pila. También
puede ver métricas acumuladas
para la aplicación y crear
paneles de monitorización
personalizados.
Límite de tiempo de espera de Para permitir las funciones October 10, 2018
ejecución de funciones de ejecución prolongada, el
máximo tiempo de espera de
ejecución configurable se ha
aumentado de 5 minutos a 15
minutos. Para obtener más
información, consulte Límites de
AWS Lambda.
Compatibilidad con lenguaje AWS Lambda ahora admite el September 11, 2018
de PowerShell Core en AWS lenguaje de PowerShell Core.
Lambda Para obtener más información,
de Lambda con PowerShell.
Compatibilidad con el tiempo de AWS Lambda ahora admite el July 9, 2018

ejecución. de NET Core 2.1.0 en tiempo de ejecución de .NET
AWS Lambda Core 2.1.0. Para obtener más
información, consulte CLI
de .NET Core.
Actualizaciones ahora Ahora puede suscribirse a una July 5, 2018

disponibles sobre RSS fuente RSS para seguir las
versiones de esta guía.
Región China (Ningxia) AWS Lambda ya está disponible June 28, 2018
en la Región China (Ningxia).
Para obtener más información
acerca de las regiones y los
puntos de enlace de Lambda,
consulte Regiones y puntos
de enlace en la AWS General
Reference.
498
Actualizaciones anteriores
Compatibilidad con Amazon SQS AWS Lambda ahora admite June 28, 2018
como origen de eventos Amazon Simple Queue Service
(Amazon SQS) como origen
de eventos. Para obtener más
información, consulte Invocación
de funciones de Lambda.
En la siguiente tabla, se describen los cambios importantes que se han realizado en cada una de las
versiones de la Guía para desarrolladores de AWS Lambda anteriores a junio de 2018.
Cambio Descripción Fecha
Compatibilidad con AWS Lambda ahora es compatible con la versión 8.10 2 de abril
tiempo de ejecución 8.10 de tiempo de ejecución de Node.js. Para obtener más de 2018
de Node.js información, consulte Creación de funciones de Lambda con
Node.js (p. 332).
ID de revisión de los AWS Lambda admite ahora los ID de revisión en los alias 25 de
alias y las funciones y las versiones de las funciones. Puede usar estos ID para enero de
realizar un seguimiento de las actualizaciones condicionales 2018
y aplicarlas al actualizar los recursos de alias o la versión de
función.
Soporte del tiempo AWS Lambda ha agregado compatibilidad del tiempo de 15 de

de ejecución para Go ejecución para Go y .NET 2.0. Para obtener más información, enero de
y .NET 2.0 consulte Creación de funciones de Lambda con Go (p. 417) y 2018
Creación de funciones Lambda con C# (p. 432).
Rediseño de la consola AWS Lambda presenta una nueva consola de Lambda para 30 de
simplificar su experiencia y se ha añadido un Cloud9 Code noviembre
Editor para mejorar su capacidad de depurar y revisar el código de 2017
de las funciones. Para obtener más información, consulte
Creación de funciones mediante el editor de la consola de AWS
Lambda (p. 7).
Definición de límites de AWS Lambda admite ahora la definición de límites de 30 de

simultaneidad para cada simultaneidad para cada función. Para obtener más noviembre
función información, consulte Administración de la simultaneidad para de 2017
una función de Lambda (p. 62).
Desvío de tráfico AWS Lambda admite ahora el desvío de tráfico con alias. Para 28 de
mediante alias obtener más información, consulte Implementaciones continuas noviembre
para funciones de Lambda (p. 156). de 2017
Implementación de AWS Lambda permite ahora implementar de forma segura 28 de

código gradual nuevas versiones de su función de Lambda utilizando noviembre
Code Deploy. Para obtener más información, consulte de 2017
Implementación de código gradual.
Región China (Pekín) AWS Lambda ya está disponible en la Región China (Pekín). 9 de
Para obtener más información acerca de las regiones y los noviembre
puntos de enlace de Lambda, consulte Regiones y puntos de de 2017
enlace en la AWS General Reference.
499
Presentación de SAM AWS Lambda presenta SAM Local (denominado también 11 de

Local SAM CLI), una herramienta de la AWS CLI que proporciona agosto de
un entorno para desarrollar, probar y analizar localmente 2017
aplicaciones sin servidor antes de cargarlas en el motor de
tiempo de ejecución de Lambda. Para obtener más información,
consulte el tema relacionado con la prueba y depuración de
aplicaciones sin servidor.
Región Canadá (Central) AWS Lambda ya está disponible en la Región Canadá 22 de junio
(Central). Para obtener más información acerca de las regiones de 2017
y los puntos de enlace de Lambda, consulte Regiones y puntos
de enlace en la AWS General Reference.
Región América del Sur AWS Lambda ya está disponible en la Región América del 6 de junio
(São Paulo) Sur (São Paulo). Para obtener más información acerca de las de 2017
regiones y los puntos de enlace de Lambda, consulte Regiones
y puntos de enlace en la AWS General Reference.
Compatibilidad de AWS Lambda introduce la compatibilidad con X-Ray, que permite 19 de abril
Lambda para AWS X- detectar, analizar y optimizar problemas de desempeño con de 2017
Ray. las aplicaciones de Lambda. Para obtener más información,
consulte Uso de AWS Lambda con AWS X-Ray (p. 311).
Región Asia Pacífico AWS Lambda ya está disponible en la Región Asia Pacífico 28 de
(Mumbai) (Mumbai). Para obtener más información acerca de las marzo de
regiones y los puntos de enlace de Lambda, consulte Regiones 2017
AWS Lambda ahora es AWS Lambda ha agregado compatibilidad con el tiempo 22 de

compatible con el tiempo de ejecución v6.10 de Node.js. Para obtener más marzo de
de ejecución v6.10 de información, consulte Creación de funciones de Lambda con 2017
Node.js Node.js (p. 332).
Región de Europa AWS Lambda ya está disponible en la Región de Europa 1 de

(Londres) (Londres). Para obtener más información acerca de las febrero de
regiones y los puntos de enlace de Lambda, consulte Regiones 2017
Compatibilidad de AWS AWS Lambda incorpora compatibilidad con C#. Para obtener 3 de
Lambda con el tiempo más información, consulte Creación de funciones Lambda con diciembre
de ejecución de .NET, C# (p. 432). de 2016
Lambda@Edge (vista
previa), las colas de Lambda@Edge le permite ejecutar funciones de Lambda en
mensajes fallidos y las ubicaciones de borde de AWS en respuesta a eventos de
la implementación CloudFront. Para obtener más información, consulte Uso de
automatizada de las AWS Lambda con CloudFront Lambda@Edge (p. 205).
aplicaciones sin servidor
AWS Lambda agrega Con Lambda y Amazon Lex, puede crear rápidamente bots 30 de
Amazon Lex como de chat para diversos servicios, como Slack y Facebook. Para noviembre
origen de eventos obtener más información, consulte Uso de AWS Lambda con de 2016
compatible. Amazon Lex (p. 265).
500
EE.UU. Oeste (Norte de AWS Lambda ya está disponible en la EE.UU. Oeste (Norte 21 de
California) de California). Para obtener más información acerca de las noviembre
regiones y los puntos de enlace de Lambda, consulte Regiones de 2016
Se presenta AWS AWS Serverless Application Model: ahora puede utilizar AWS 18 de
Serverless Application SAM para definir la sintaxis para expresar recursos dentro de noviembre
Model, que permite una aplicación sin servidor. Para implementar la aplicación, de 2016
crear e implementar solo tiene que especificar los recursos que necesita que formen
aplicaciones basadas parte de ella, junto con sus políticas de permisos asociadas
en Lambda y utilizar en un archivo de plantilla de AWS CloudFormation (escrito en
variables de entorno JSON o YAML), empaquetar sus artefactos de implementación
para los ajustes de e implementar la plantilla. Para obtener más información,
configuración de las consulte Aplicaciones de AWS Lambda (p. 144).
funciones de Lambda.
Variables de entorno: puede utilizar variables de entorno para
especificar las opciones de configuración de una función de
Lambda fuera del código de la función. Para obtener más
información, consulte Uso de variables de entorno de AWS
Lambda (p. 56).
Región Asia Pacífico AWS Lambda ya está disponible en la Región Asia Pacífico 29 de
(Seúl) (Seúl). Para obtener más información acerca de las regiones y agosto de
los puntos de enlace de Lambda, consulte Regiones y puntos 2016
de enlace en la AWS General Reference.
Región Asia Pacífico Lambda ya está disponible en la Región Asia Pacífico (Sídney). 23 de junio
(Sídney) Para obtener más información acerca de las regiones y los de 2016
puntos de enlace de Lambda, consulte Regiones y puntos de
Actualizaciones de la La consola de Lambda se ha actualizado para simplificar el 23 de junio

consola de Lambda proceso de creación de roles. Para obtener más información, de 2016
consulte Creación de una función Lambda con la consola (p. 3).
AWS Lambda ahora es AWS Lambda ha agregado compatibilidad con el tiempo 07 de abril
compatible con el tiempo de ejecución v4.3. Para obtener más información, consulte de 2016
de ejecución v4.3 de Creación de funciones de Lambda con Node.js (p. 332).
Node.js
Región Europa Lambda ya está disponible en la región Europa (Fráncfort). 14 de

(Fráncfort) Para obtener más información acerca de las regiones y los marzo de
puntos de enlace de Lambda, consulte Regiones y puntos de 2016
Compatibilidad con VPC Ahora puede configurar una función de Lambda para obtener 11 de
acceso a los recursos de una VPC. Para obtener más febrero de
información, consulte Configuración de una función de Lambda 2016
para obtener acceso a los recursos de una VPC (p. 81).
Se ha actualizado el El entorno de ejecución (p. 130) se ha actualizado. 4 de

tiempo de ejecución de noviembre
AWS Lambda. de 2015
501
Compatibilidad con el Ahora puede desarrollar el código de las funciones de Lambda 08 de

control de versiones, con Python. Para obtener más información, consulte Creación octubre de
Python para desarrollar de funciones de Lambda con Python (p. 349). 2015
código para las
funciones de Lambda, Control de versiones: puede mantener una o varias versiones
eventos programados y de una función de Lambda. El control de versiones permite
aumento del tiempo de controlar qué versión de una función de Lambda se ejecuta
ejecución en los distintos entornos (por ejemplo, desarrollo, pruebas, o
producción). Para obtener más información, consulte Versiones
de funciones de AWS Lambda (p. 70).
Eventos programados: también puede configurar AWS Lambda

para que invoque el código de forma periódica y programada
utilizando la consola de AWS Lambda. Puede especificar una
frecuencia fija (un número de horas, días o semanas) o una
expresión cron. Para ver un ejemplo, consulte Uso de AWS
Lambda con Amazon CloudWatch Events (p. 196).
Aumento del tiempo de ejecución: a partir de ahora, puede

configurar las funciones de Lambda para que se ejecuten
durante un máximo de cinco minutos, lo que permite utilizar
funciones con tiempos de ejecución más largos como, por
ejemplo, trabajos de adquisición y procesamiento de grandes
volúmenes de datos.
Compatibilidad con DynamoDB Streams ya está disponible con carácter general 14 de julio
DynamoDB Streams y se puede utilizar en todas las regiones en las que está de 2015
disponible. Puede activar DynamoDB Streams para una tabla
y utilizar una función de Lambda como un disparador para la
tabla. Los disparadores son acciones personalizadas que se
llevan a cabo en respuesta a las actualizaciones realizadas
en la tabla de DynamoDB. Para ver un tutorial de ejemplo,
consulte Tutorial: Uso de AWS Lambda con flujos de Amazon
DynamoDB (p. 223).
AWS Lambda ahora Hasta ahora, para invocar una función de Lambda desde 09 de julio
permite invocar aplicaciones web, móviles o IoT, se necesitaban los SDK de de 2015
funciones de Lambda AWS (por ejemplo, AWS SDK para Java, AWS SDK para
con clientes compatibles Android o AWS SDK para iOS). Ahora, AWS Lambda permite
con REST. invocar una función de Lambda con clientes compatibles con
REST a través de una API personalizada que puede crear con
Amazon API Gateway. Puede enviar solicitudes a la URL del
punto de enlace de una función de Lambda. Puede configurar
la seguridad en el punto de enlace para permitir el acceso
libre, utilizar AWS Identity and Access Management (IAM)
para autorizar el acceso, o utilizar claves de API para medir el
acceso de otros usuarios a sus funciones de Lambda.
Para ver un ejemplo de ejercicio de introducción, consulte Uso

de AWS Lambda con Amazon API Gateway (p. 165).
Para obtener más información sobre Amazon API Gateway,

consulte https://aws.amazon.com/api-gateway/.
502
La consola de AWS La consola de AWS Lambda proporciona un conjunto de 09 de julio

Lambda ahora ofrece proyectos. Cada proyecto ofrece una configuración de origen de 2015
proyectos para crear de eventos de muestra y código de muestra para la función de
fácilmente funciones de Lambda que puede utilizar para crear fácilmente aplicaciones
Lambda y probarlas. basadas en Lambda. Ahora, todos los ejercicios de introducción
de AWS Lambda utilizan proyectos. Para obtener más
información, consulte Introducción a AWS Lambda (p. 3).
AWS Lambda ahora A partir de ahora, puede escribir el código de Lambda en Java. 15 de junio
permite utilizar Java Para obtener más información, consulte Creación de funciones de 2015
para crear funciones de de Lambda con Java (p. 383).
Lambda.
AWS Lambda ahora Puede cargar el paquete de implementación (archivo.zip) de 28 de mayo

permite especificar un una función de Lambda en un bucket de Amazon S3 de la de 2015
objeto de Amazon S3 misma región en la que desea crear la función de Lambda.
como archivo .zip de A continuación, puede especificar el nombre del bucket y un
la función al crear o nombre de la clave de objeto al crear o actualizar una función
actualizar una función de de Lambda.
Lambda.
AWS Lambda ahora AWS Lambda ya se encuentra disponible con carácter general 9 de abril
está disponible con para su uso con fines de producción. La versión también de 2015
carácter general con presenta características nuevas que facilitan la creación de
soporte para backends backends para móviles, tablets e Internet de las cosas (IoT) con
para móviles AWS Lambda que se escalan automáticamente sin necesidad
de aprovisionar ni administrar infraestructura. AWS Lambda
ahora es compatible con eventos en tiempo real (síncronos) y
asíncronos. También incluye una configuración y administración
de orígenes de eventos más sencilla. El modelo de permisos
y el modelo de programación se han simplificado mediante
la introducción de políticas de recursos para las funciones de
Lambda.
La documentación se ha actualizado en consecuencia. Para

obtener información, consulte los siguientes temas:
Introducción a AWS Lambda (p. 3)
AWS Lambda
Versión de prueba Versión de prueba de la Guía para desarrolladores de AWS 13 de

Lambda. noviembre
de 2014
503
Actions
Referencia de la API
Esta sección contiene la documentación de referencia de la AWS Lambda. Cuando haga llamadas a la
API, deberá autenticar la solicitud proporcionando una firma. AWS Lambda es compatible con Signature
Version 4. Para obtener más información, consulte Proceso de firma Signature Version 4 en la Referencia
general de Amazon Web Services.
Para obtener información general acerca del servicio, consulte ¿Qué es AWS Lambda? (p. 1).
Puede utilizar la AWS CLI para explorar la API de AWS Lambda. Esta guía proporciona varios tutoriales
que utilizan la AWS CLI.
Temas
• Actions (p. 504)

• Data Types (p. 679)
Actions
The following actions are supported:
• AddLayerVersionPermission (p. 506)

• DeleteFunctionEventInvokeConfig (p. 544)
• DeleteLayerVersion (p. 546)
• DeleteProvisionedConcurrencyConfig (p. 548)
• GetAccountSettings (p. 550)
• GetAlias (p. 552)
• GetFunctionConcurrency (p. 563)
• GetFunctionEventInvokeConfig (p. 571)
• GetLayerVersion (p. 574)
• GetLayerVersionByArn (p. 577)
• GetLayerVersionPolicy (p. 580)
• GetProvisionedConcurrencyConfig (p. 584)
• Invoke (p. 587)
504
Actions
• InvokeAsync (p. 593)

• ListAliases (p. 595)
• ListFunctionEventInvokeConfigs (p. 601)
• ListLayers (p. 607)
• ListLayerVersions (p. 609)
• ListProvisionedConcurrencyConfigs (p. 612)
• ListTags (p. 615)
• ListVersionsByFunction (p. 617)
• PublishLayerVersion (p. 620)
• PutFunctionEventInvokeConfig (p. 634)
• PutProvisionedConcurrencyConfig (p. 638)
• RemoveLayerVersionPermission (p. 641)
• TagResource (p. 645)
• UntagResource (p. 647)
• UpdateFunctionEventInvokeConfig (p. 676)
505
AddLayerVersionPermission
Adds permissions to the resource-based policy of a version of an AWS Lambda layer. Use this action to
grant layer usage permission to other accounts. You can grant permission to a single account, all AWS
accounts, or all accounts in an organization.
To revoke permission, call RemoveLayerVersionPermission (p. 641) with the statement ID that you
specified when you added it.
Request Syntax
POST /2018-10-31/layers/LayerName/versions/VersionNumber/policy?RevisionId=RevisionId
HTTP/1.1
Content-type: application/json
{
"Action": "string",
"OrganizationId": "string",
"Principal": "string",
"StatementId": "string"
}
URI Request Parameters

The request uses the following URI parameters.
LayerName (p. 506)
The name or Amazon Resource Name (ARN) of the layer.
Length Constraints: Minimum length of 1. Maximum length of 140.
Pattern: (arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+)|
[a-zA-Z0-9-_]+
Required: Yes
RevisionId (p. 506)
Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a
policy that has changed since you last read it.
VersionNumber (p. 506)
The version number.
Required: Yes
Request Body
The request accepts the following data in JSON format.
Action (p. 506)
The API action that grants access to the layer. For example, lambda:GetLayerVersion.
Type: String
Pattern: lambda:GetLayerVersion
506
Required: Yes
OrganizationId (p. 506)
With the principal set to *, grant permission to all accounts in the specified organization.
Type: String
Pattern: o-[a-z0-9]{10,32}
Required: No
Principal (p. 506)
An account ID, or * to grant permission to all AWS accounts.
Type: String
Pattern: \d{12}|\*|arn:(aws[a-zA-Z-]*):iam::\d{12}:root
Required: Yes
StatementId (p. 506)
An identifier that distinguishes the policy from others on the same layer version.
Type: String
Pattern: ([a-zA-Z0-9-_]+)
Required: Yes
Response Syntax
HTTP/1.1 201
{
"RevisionId": "string",
"Statement": "string"
}
Response Elements
If the action is successful, the service sends back an HTTP 201 response.
The following data is returned in JSON format by the service.
RevisionId (p. 507)
A unique identifier for the current revision of the policy.
Type: String
Statement (p. 507)
The permission statement.
Type: String
507
Errors
InvalidParameterValueException
One of the parameters in the request is invalid.
HTTP Status Code: 400

PolicyLengthExceededException
The permissions policy for the resource is too large. Learn more

PreconditionFailedException
The RevisionId provided does not match the latest RevisionId for the Lambda function or alias. Call the
GetFunction or the GetAlias API to retrieve the latest RevisionId for your resource.

ResourceConflictException
The resource already exists, or another operation is in progress.

ResourceNotFoundException
The resource specified in the request does not exist.

ServiceException
The AWS Lambda service encountered an internal error.

TooManyRequestsException
The request throughput limit was exceeded.
See Also
For more information about using this API in one of the language-specific AWS SDKs, see the following:
• AWS Command Line Interface

• AWS SDK for .NET
• AWS SDK for C++
• AWS SDK for Go
• AWS SDK for Java
• AWS SDK for JavaScript
• AWS SDK for PHP V3
• AWS SDK for Python
• AWS SDK for Ruby V3
508
AddPermission
AddPermission
Grants an AWS service or another account permission to use a function. You can apply the policy at the
function level, or specify a qualifier to restrict access to a single version or alias. If you use a qualifier, the
invoker must use the full Amazon Resource Name (ARN) of that version or alias to invoke the function.
To grant permission to another account, specify the account ID as the Principal. For AWS
services, the principal is a domain-style identifier defined by the service, like s3.amazonaws.com or
sns.amazonaws.com. For AWS services, you can also specify the ARN of the associated resource as
the SourceArn. If you grant permission to a service principal without specifying the source, other accounts
could potentially configure resources in their account to invoke your Lambda function.
This action adds a statement to a resource-based permissions policy for the function. For more information
about function policies, see Lambda Function Policies.
Request Syntax
POST /2015-03-31/functions/FunctionName/policy?Qualifier=Qualifier HTTP/1.1
{
"Action": "string",
"EventSourceToken": "string",
"Principal": "string",
"SourceAccount": "string",
"SourceArn": "string",
"StatementId": "string"
}

FunctionName (p. 509)
The name of the Lambda function, version, or alias.
Name formats
• Function name - my-function (name-only), my-function:v1 (with alias).
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:my-function.
• Partial ARN - 123456789012:function:my-function.
You can append a version number or alias to any of the formats. The length constraint applies only to
the full ARN. If you specify only the function name, it is limited to 64 characters in length.
Pattern: (arn:(aws[a-zA-Z-]*)?:lambda:)?([a-z]{2}(-gov)?-[a-z]+-\d{1}:)?
(\d{12}:)?(function:)?([a-zA-Z0-9-_]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Required: Yes
Qualifier (p. 509)
Specify a version or alias to add permissions to a published version of the function.
509
AddPermission
Pattern: (|[a-zA-Z0-9$_-]+)
Request Body
Action (p. 509)
The action that the principal can use on the function. For example, lambda:InvokeFunction or
lambda:GetFunction.
Type: String
Pattern: (lambda:[*]|lambda:[a-zA-Z]+|[*])
Required: Yes
EventSourceToken (p. 509)
For Alexa Smart Home functions, a token that must be supplied by the invoker.
Type: String
Pattern: [a-zA-Z0-9._\-]+
Required: No
Principal (p. 509)
The AWS service or account that invokes the function. If you specify a service, use SourceArn or
SourceAccount to limit who can invoke the function through that service.
Type: String
Pattern: .*
Required: Yes
RevisionId (p. 509)
Only update the policy if the revision ID matches the ID that's specified. Use this option to avoid
modifying a policy that has changed since you last read it.
Type: String
Required: No
SourceAccount (p. 509)
For Amazon S3, the ID of the account that owns the resource. Use this together with SourceArn to
ensure that the resource is owned by the specified account. It is possible for an Amazon S3 bucket to
be deleted by its owner and recreated by another account.
Type: String
Pattern: \d{12}
Required: No
SourceArn (p. 509)
For AWS services, the ARN of the AWS resource that invokes the function. For example, an Amazon
S3 bucket or Amazon SNS topic.
510
AddPermission
Type: String
Pattern: arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
Required: No
A statement identifier that differentiates the statement from others in the same policy.
Type: String
Required: Yes
Response Syntax
HTTP/1.1 201
{
"Statement": "string"
}
Response Elements
Statement (p. 511)
The permission statement that's added to the function policy.
Type: String
Errors

PolicyLengthExceededException
The permissions policy for the resource is too large. Learn more

511
AddPermission


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
512
CreateAlias
CreateAlias
Creates an alias for a Lambda function version. Use aliases to provide clients with a function identifier that
you can update to invoke a different version.
You can also map an alias to split invocation requests between two versions. Use the RoutingConfig
parameter to specify a second version and the percentage of invocation requests that it receives.
Request Syntax
POST /2015-03-31/functions/FunctionName/aliases HTTP/1.1
{
"Description": "string",
"FunctionVersion": "string",
"Name": "string",
"RoutingConfig": {
"AdditionalVersionWeights": {
"string" : number
}
}
}

The name of the Lambda function.
Name formats
• Function name - MyFunction.
• Function ARN - arn:aws:lambda:us-west-2:123456789012:function:MyFunction.
• Partial ARN - 123456789012:function:MyFunction.
The length constraint applies only to the full ARN. If you specify only the function name, it is limited to
64 characters in length.
Required: Yes
Request Body
Description (p. 513)
A description of the alias.
Type: String
513
CreateAlias
Required: No
FunctionVersion (p. 513)
The function version that the alias invokes.
Type: String
Pattern: (\$LATEST|[0-9]+)
Required: Yes
Name (p. 513)
The name of the alias.
Type: String
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
Required: Yes
RoutingConfig (p. 513)
The routing configuration of the alias.
Type: AliasRoutingConfiguration (p. 685) object
Required: No
Response Syntax
HTTP/1.1 201
{
"AliasArn": "string",
"Name": "string",
"RoutingConfig": {
"string" : number
}
}
}
Response Elements
AliasArn (p. 514)
The Amazon Resource Name (ARN) of the alias.
514
CreateAlias
Type: String
Pattern: arn:(aws[a-zA-Z-]*)?:lambda:[a-z]{2}(-gov)?-[a-z]+-\d{1}:
\d{12}:function:[a-zA-Z0-9-_]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
Type: String

Type: String
Name (p. 514)
Type: String
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 514)
A unique identifier that changes when you update the alias.
Type: String
Errors


515
CreateAlias
ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
516
CreateEventSourceMapping
Creates a mapping between an event source and an AWS Lambda function. Lambda reads items from the
event source and triggers the function.
For details about each event source type, see the following topics.
• Using AWS Lambda with Amazon DynamoDB

• Using AWS Lambda with Amazon Kinesis
• Using AWS Lambda with Amazon SQS
• Using AWS Lambda with Amazon MSK
The following error handling options are only available for stream sources (DynamoDB and Kinesis):
• BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
• DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
• MaximumRecordAgeInSeconds - Discard records older than the specified age. Default -1 (infinite).
Minimum 60. Maximum 604800.
• MaximumRetryAttempts - Discard records after the specified number of retries. Default -1 (infinite).
Minimum 0. Maximum 10000. When infinite, failed records will be retried until the record expires.
• ParallelizationFactor - Process multiple batches from each shard concurrently.
Request Syntax
POST /2015-03-31/event-source-mappings/ HTTP/1.1
{
"BatchSize": number,
"BisectBatchOnFunctionError": boolean,
"OnFailure": {
"Destination": "string"
},
"OnSuccess": {
}
},
"Enabled": boolean,
"EventSourceArn": "string",
"FunctionName": "string",
"MaximumBatchingWindowInSeconds": number,
"MaximumRecordAgeInSeconds": number,
"MaximumRetryAttempts": number,
"ParallelizationFactor": number,
"StartingPosition": "string",
"StartingPositionTimestamp": number,
"Topics": [ "string" ]
}

The request does not use any URI parameters.
517
Request Body
BatchSize (p. 517)
The maximum number of items to retrieve in a single batch.

• Amazon Kinesis - Default 100. Max 10,000.
• Amazon DynamoDB Streams - Default 100. Max 1,000.
• Amazon Simple Queue Service - Default 10. Max 10.
• Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.
Type: Integer
Valid Range: Minimum value of 1. Maximum value of 10000.
Required: No
BisectBatchOnFunctionError (p. 517)
(Streams) If the function returns an error, split the batch in two and retry.
Type: Boolean
Required: No
DestinationConfig (p. 517)
(Streams) An Amazon SQS queue or Amazon SNS topic destination for discarded records.
Type: DestinationConfig (p. 688) object
Required: No
Enabled (p. 517)
If true, the event source mapping is active. Set to false to pause polling and invocation.
Type: Boolean
Required: No
EventSourceArn (p. 517)
The Amazon Resource Name (ARN) of the event source.

• Amazon Kinesis - The ARN of the data stream or a stream consumer.
• Amazon DynamoDB Streams - The ARN of the stream.
• Amazon Simple Queue Service - The ARN of the queue.
• Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.
Type: String
\d{1})?:(\d{12})?:(.*)
Required: Yes
518
Name formats
• Version or Alias ARN - arn:aws:lambda:us-
west-2:123456789012:function:MyFunction:PROD.
The length constraint applies only to the full ARN. If you specify only the function name, it's limited to
Type: String
Required: Yes
MaximumBatchingWindowInSeconds (p. 517)
(Streams) The maximum amount of time to gather records before invoking the function, in seconds.
Type: Integer
Required: No
MaximumRecordAgeInSeconds (p. 517)
(Streams) Discard records older than the specified age. The default value is infinite (-1).
Type: Integer
Valid Range: Minimum value of -1. Maximum value of 604800.
Required: No
MaximumRetryAttempts (p. 517)
(Streams) Discard records after the specified number of retries. The default value is infinite (-1). When
set to infinite (-1), failed records will be retried until the record expires.
Type: Integer
Required: No
ParallelizationFactor (p. 517)
(Streams) The number of batches to process from each shard concurrently.
Type: Integer
Required: No
StartingPosition (p. 517)
The position in a stream from which to start reading. Required for Amazon Kinesis, Amazon
DynamoDB, and Amazon MSK Streams sources. AT_TIMESTAMP is only supported for Amazon
Kinesis streams.
519
Type: String
Valid Values: TRIM_HORIZON | LATEST | AT_TIMESTAMP
Required: No
StartingPositionTimestamp (p. 517)
With StartingPosition set to AT_TIMESTAMP, the time from which to start reading, in Unix time
seconds.
Type: Timestamp
Required: No
Topics (p. 517)
(MSK) The name of the Kafka topic.
Type: Array of strings
Array Members: Fixed number of 1 item.
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
Required: No
Response Syntax
HTTP/1.1 202
{
"OnFailure": {
},
"OnSuccess": {
}
},
"FunctionArn": "string",
"LastModified": number,
"LastProcessingResult": "string",
"State": "string",
"StateTransitionReason": "string",
"Topics": [ "string" ],
"UUID": "string"
}
Response Elements
520
BatchSize (p. 520)
Type: Integer

Type: Boolean

Type: String
\d{1})?:(\d{12})?:(.*)
FunctionArn (p. 520)
The ARN of the Lambda function.
Type: String
LastModified (p. 520)
The date that the event source mapping was last updated, or its state changed, in Unix time seconds.
Type: Timestamp
LastProcessingResult (p. 520)
The result of the last AWS Lambda invocation of your Lambda function.
Type: String
Type: Integer

(Streams) The maximum age of a record that Lambda sends to a function for processing.
Type: Integer
521
(Streams) The maximum number of times to retry when the function returns an error.
Type: Integer

Type: Integer

State (p. 520)
The state of the event source mapping. It can be one of the following: Creating, Enabling,
Enabled, Disabling, Disabled, Updating, or Deleting.
Type: String
StateTransitionReason (p. 520)
Indicates whether the last change to the event source mapping was made by a user, or by the Lambda
service.
Type: String
Topics (p. 520)
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
UUID (p. 520)
The identifier of the event source mapping.
Type: String
Errors


522

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
523
CreateFunction
CreateFunction
Creates a Lambda function. To create a function, you need a deployment package and an execution role.
The deployment package contains your function code. The execution role grants the function permission
to use AWS services, such as Amazon CloudWatch Logs for log streaming and AWS X-Ray for request
tracing.
When you create a function, Lambda provisions an instance of the function and its supporting resources.
If your function connects to a VPC, this process can take a minute or so. During this time, you can't invoke
or modify the function. The State, StateReason, and StateReasonCode fields in the response from
GetFunctionConfiguration (p. 565) indicate when the function is ready to invoke. For more information,
see Function States.
A function has an unpublished version, and can have published versions and aliases. The unpublished
version changes when you update your function's code and configuration. A published version is a
snapshot of your function code and configuration that can't be changed. An alias is a named resource
that maps to a version, and can be changed to map to a different version. Use the Publish parameter to
create version 1 of your function from its initial configuration.
The other parameters let you configure version-specific and function-level settings. You can modify version-
specific settings later with UpdateFunctionConfiguration (p. 667). Function-level settings apply to both the
unpublished and published versions of the function, and include tags (TagResource (p. 645)) and per-
function concurrency limits (PutFunctionConcurrency (p. 631)).
If another account or an AWS service invokes your function, use AddPermission (p. 509) to grant
permission by creating a resource-based IAM policy. You can grant permissions at the function level, on a
version, or on an alias.
To invoke your function directly, use Invoke (p. 587). To invoke your function in response to events in
other AWS services, create an event source mapping (CreateEventSourceMapping (p. 517)), or configure a
function trigger in the other service. For more information, see Invoking Functions.
Request Syntax
POST /2015-03-31/functions HTTP/1.1
{
"Code": {
"S3Bucket": "string",
"S3Key": "string",
"S3ObjectVersion": "string",
"ZipFile": blob
},
"DeadLetterConfig": {
"TargetArn": "string"
},
"Environment": {
"Variables": {
"string" : "string"
}
},
"FileSystemConfigs": [
{
"Arn": "string",
"LocalMountPath": "string"
}
],
524
CreateFunction
"Handler": "string",
"KMSKeyArn": "string",
"Layers": [ "string" ],
"MemorySize": number,
"Publish": boolean,
"Role": "string",
"Runtime": "string",
"Tags": {
"string" : "string"
},
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"SecurityGroupIds": [ "string" ],
"SubnetIds": [ "string" ]
}
}

Request Body
Code (p. 524)
The code for the function.
Type: FunctionCode (p. 696) object
Required: Yes
DeadLetterConfig (p. 524)
A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous
events when they fail processing. For more information, see Dead Letter Queues.
Type: DeadLetterConfig (p. 687) object
Required: No
A description of the function.
Type: String
Required: No
Environment (p. 524)
Environment variables that are accessible from function code during execution.
Type: Environment (p. 689) object
Required: No
525
CreateFunction
FileSystemConfigs (p. 524)
Connection settings for an Amazon EFS file system.
Type: Array of FileSystemConfig (p. 695) objects
Array Members: Maximum number of 1 item.
Required: No
Name formats
• Function name - my-function.
Type: String
Required: Yes
Handler (p. 524)
The name of the method within your code that Lambda calls to execute your function. The format
includes the file name. It can also include namespaces and other qualifiers, depending on the runtime.
For more information, see Programming Model.
Type: String
Length Constraints: Maximum length of 128.
Pattern: [^\s]+
Required: Yes
KMSKeyArn (p. 524)
The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's
environment variables. If it's not provided, AWS Lambda uses a default service key.
Type: String
Pattern: (arn:(aws[a-zA-Z-]*)?:[a-z0-9-.]+:.*)|()
Required: No
Layers (p. 524)
A list of function layers to add to the function's execution environment. Specify each layer by its ARN,
including the version.
526
CreateFunction
Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+:
[0-9]+
Required: No
MemorySize (p. 524)
The amount of memory that your function has access to. Increasing the function's memory also
increases its CPU allocation. The default value is 128 MB. The value must be a multiple of 64 MB.
Type: Integer
Required: No
Publish (p. 524)
Set to true to publish the first version of the function during creation.
Type: Boolean
Required: No
Role (p. 524)
The Amazon Resource Name (ARN) of the function's execution role.
Type: String
Pattern: arn:(aws[a-zA-Z-]*)?:iam::\d{12}:role/?[a-zA-Z_0-9+=,.@\-_/]+
Required: Yes
Runtime (p. 524)
The identifier of the function's runtime.
Type: String
Valid Values: nodejs | nodejs4.3 | nodejs6.10 | nodejs8.10 | nodejs10.x |

nodejs12.x | java8 | java8.al2 | java11 | python2.7 | python3.6 | python3.7
| python3.8 | dotnetcore1.0 | dotnetcore2.0 | dotnetcore2.1 | dotnetcore3.1
| nodejs4.3-edge | go1.x | ruby2.5 | ruby2.7 | provided | provided.al2
Required: Yes
Tags (p. 524)
A list of tags to apply to the function.
Type: String to string map
Required: No
Timeout (p. 524)
The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds.
The maximum allowed value is 900 seconds.
Type: Integer
Valid Range: Minimum value of 1.
527
CreateFunction
Required: No
TracingConfig (p. 524)
Set Mode to Active to sample and trace a subset of incoming requests with AWS X-Ray.
Type: TracingConfig (p. 715) object
Required: No
VpcConfig (p. 524)
For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in
the VPC. When you connect a function to a VPC, it can only access resources and the internet through
that VPC. For more information, see VPC Settings.
Type: VpcConfig (p. 717) object
Required: No
Response Syntax
HTTP/1.1 201
{
"CodeSha256": "string",
"CodeSize": number,
},
"Environment": {
"Error": {
"ErrorCode": "string",
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"LastModified": "string",
"LastUpdateStatus": "string",
"LastUpdateStatusReason": "string",
"LastUpdateStatusReasonCode": "string",
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"MasterArn": "string",
528
CreateFunction
"Role": "string",
"State": "string",
"StateReason": "string",
"StateReasonCode": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"Version": "string",
"VpcConfig": {
"SubnetIds": [ "string" ],
"VpcId": "string"
}
}
Response Elements
CodeSha256 (p. 528)
The SHA256 hash of the function's deployment package.
Type: String
CodeSize (p. 528)
The size of the function's deployment package, in bytes.
Type: Long
The function's dead letter queue.

The function's description.
Type: String

The function's environment variables.
Type: EnvironmentResponse (p. 691) object


The function's Amazon Resource Name (ARN).
529
CreateFunction
Type: String
\d{12}:function:[a-zA-Z0-9-_\.]+(:(\$LATEST|[a-zA-Z0-9-_]+))?
The name of the function.
Type: String
(\d{12}:)?(function:)?([a-zA-Z0-9-_\.]+)(:(\$LATEST|[a-zA-Z0-9-_]+))?
Handler (p. 528)
The function that Lambda calls to begin executing your function.
Type: String
Pattern: [^\s]+
KMSKeyArn (p. 528)
The KMS key that's used to encrypt the function's environment variables. This key is only returned if
you've configured a customer managed CMK.
Type: String
The date and time that the function was last updated, in ISO-8601 format (YYYY-MM-
DDThh:mm:ss.sTZD).
Type: String
LastUpdateStatus (p. 528)
The status of the last update that was performed on the function. This is first set to Successful after
function creation completes.
Type: String
Valid Values: Successful | Failed | InProgress

LastUpdateStatusReason (p. 528)
The reason for the last update that was performed on the function.
Type: String
LastUpdateStatusReasonCode (p. 528)
The reason code for the last update that was performed on the function.
Type: String
Valid Values: EniLimitExceeded | InsufficientRolePermissions |

InvalidConfiguration | InternalError | SubnetOutOfIPAddresses |
InvalidSubnet | InvalidSecurityGroup
530
CreateFunction
Layers (p. 528)
The function's layers.
Type: Array of Layer (p. 705) objects

MasterArn (p. 528)
For Lambda@Edge functions, the ARN of the master function.
Type: String
MemorySize (p. 528)
The memory that's allocated to the function.
Type: Integer

RevisionId (p. 528)
The latest updated revision of the function or alias.
Type: String
Role (p. 528)
The function's execution role.
Type: String
Runtime (p. 528)
The runtime environment for the Lambda function.
Type: String

State (p. 528)
The current state of the function. When the state is Inactive, you can reactivate the function by
invoking it.
Type: String
Valid Values: Pending | Active | Inactive | Failed

StateReason (p. 528)
The reason for the function's current state.
Type: String
StateReasonCode (p. 528)
The reason code for the function's current state. When the code is Creating, you can't invoke or
modify the function.
531
CreateFunction
Type: String
Valid Values: Idle | Creating | Restoring | EniLimitExceeded |

InsufficientRolePermissions | InvalidConfiguration | InternalError |
SubnetOutOfIPAddresses | InvalidSubnet | InvalidSecurityGroup
Timeout (p. 528)
The amount of time in seconds that Lambda allows a function to run before stopping it.
Type: Integer

The function's AWS X-Ray tracing configuration.
Type: TracingConfigResponse (p. 716) object

Version (p. 528)
The version of the Lambda function.
Type: String
VpcConfig (p. 528)
The function's networking configuration.
Type: VpcConfigResponse (p. 718) object
Errors
CodeStorageExceededException
You have exceeded your maximum total code size per account. Learn more




ServiceException
532
CreateFunction

See Also

• AWS SDK for C++
• AWS SDK for Go
533
DeleteAlias
DeleteAlias
Deletes a Lambda function alias.
Request Syntax
DELETE /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1

Name formats
Required: Yes
Name (p. 534)
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
Required: Yes
Request Body
The request does not have a request body.
Response Syntax
HTTP/1.1 204
Response Elements
If the action is successful, the service sends back an HTTP 204 response with an empty HTTP body.
534
DeleteAlias
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
535
DeleteEventSourceMapping
Deletes an event source mapping. You can get the identifier of a mapping from the output of
ListEventSourceMappings (p. 598).
When you delete an event source mapping, it enters a Deleting state and might not be completely
deleted for several seconds.
Request Syntax
DELETE /2015-03-31/event-source-mappings/UUID HTTP/1.1

UUID (p. 536)
Required: Yes
Request Body
Response Syntax
HTTP/1.1 202
{
"OnFailure": {
},
"OnSuccess": {
}
},
"State": "string",
"UUID": "string"
}
536
Response Elements
BatchSize (p. 536)
Type: Integer

Type: Boolean

Type: String
\d{1})?:(\d{12})?:(.*)
Type: String
Type: Timestamp
Type: String
Type: Integer

537
Type: Integer

Type: Integer

Type: Integer

State (p. 536)
Type: String
service.
Type: String
Topics (p. 536)
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
UUID (p. 536)
Type: String
Errors

ResourceInUseException
The operation conflicts with the resource's availability. For example, you attempted to update an
EventSource Mapping in CREATING, or tried to delete a EventSource mapping currently in the
UPDATING state.
538


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
539
DeleteFunction
DeleteFunction
Deletes a Lambda function. To delete a specific function version, use the Qualifier parameter.
Otherwise, all versions and aliases are deleted.
To delete Lambda event source mappings that invoke a function, use DeleteEventSourceMapping (p. 536).
For AWS services and resources that invoke your function directly, delete the trigger in the service where
you originally configured it.
Request Syntax
DELETE /2015-03-31/functions/FunctionName?Qualifier=Qualifier HTTP/1.1

The name of the Lambda function or version.
Name formats
• Function name - my-function (name-only), my-function:1 (with version).
Required: Yes
Qualifier (p. 540)
Specify a version to delete. You can't delete a version that's referenced by an alias.
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
540
DeleteFunction
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
541
DeleteFunctionConcurrency
Removes a concurrent execution limit from a function.
Request Syntax
DELETE /2017-10-31/functions/FunctionName/concurrency HTTP/1.1

Name formats
Required: Yes
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
Errors

542


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
543
DeleteFunctionEventInvokeConfig
Deletes the configuration for asynchronous invocation for a function, version, or alias.
To configure options for asynchronous invocation, use PutFunctionEventInvokeConfig (p. 634).
Request Syntax
DELETE /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 544)
A version number or alias name.
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
544
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
545
DeleteLayerVersion
DeleteLayerVersion
Deletes a version of an AWS Lambda layer. Deleted versions can no longer be viewed or added to
functions. To avoid breaking functions, a copy of the version remains in Lambda until no functions refer to it.
Request Syntax
DELETE /2018-10-31/layers/LayerName/versions/VersionNumber HTTP/1.1

LayerName (p. 546)
[a-zA-Z0-9-_]+
Required: Yes
The version number.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
Errors
ServiceException

546
DeleteLayerVersion
See Also

• AWS SDK for C++
• AWS SDK for Go
547
DeleteProvisionedConcurrencyConfig
Deletes the provisioned concurrency configuration for a function.
Request Syntax
DELETE /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier
HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 548)
The version number or alias name.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
548
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
549
GetAccountSettings
GetAccountSettings
Retrieves details about your account's limits and usage in an AWS Region.
Request Syntax
GET /2016-08-19/account-settings/ HTTP/1.1

Request Body
Response Syntax
HTTP/1.1 200
{
"AccountLimit": {
"CodeSizeUnzipped": number,
"CodeSizeZipped": number,
"ConcurrentExecutions": number,
"TotalCodeSize": number,
"UnreservedConcurrentExecutions": number
},
"AccountUsage": {
"FunctionCount": number,
"TotalCodeSize": number
}
}
Response Elements
AccountLimit (p. 550)
Limits that are related to concurrency and code storage.
Type: AccountLimit (p. 681) object

AccountUsage (p. 550)
The number of functions and amount of storage in use.
Type: AccountUsage (p. 682) object
Errors
ServiceException
550
GetAccountSettings

See Also

• AWS SDK for C++
• AWS SDK for Go
551
GetAlias
GetAlias
Returns details about a Lambda function alias.
Request Syntax
GET /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1

Name formats
Required: Yes
Name (p. 552)
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
552
GetAlias
"Name": "string",
"RoutingConfig": {
"string" : number
}
}
}
Response Elements
AliasArn (p. 552)
Type: String
Type: String

Type: String
Name (p. 552)
Type: String
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 552)
Type: String
553
GetAlias
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
554
GetEventSourceMapping
Returns details about an event source mapping. You can get the identifier of a mapping from the output of
ListEventSourceMappings (p. 598).
Request Syntax
GET /2015-03-31/event-source-mappings/UUID HTTP/1.1

UUID (p. 555)
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"OnFailure": {
},
"OnSuccess": {
}
},
"State": "string",
"UUID": "string"
}
Response Elements
555
BatchSize (p. 555)
Type: Integer

Type: Boolean

Type: String
\d{1})?:(\d{12})?:(.*)
Type: String
Type: Timestamp
Type: String
Type: Integer

Type: Integer
556
Type: Integer

Type: Integer

State (p. 555)
Type: String
service.
Type: String
Topics (p. 555)
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
UUID (p. 555)
Type: String
Errors


ServiceException
557

See Also

• AWS SDK for C++
• AWS SDK for Go
558
GetFunction
GetFunction
Returns information about the function or function version, with a link to download the deployment package
that's valid for 10 minutes. If you specify a function version, only details that are specific to that version are
returned.
Request Syntax
GET /2015-03-31/functions/FunctionName?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 559)
Specify a version or alias to get details about a published version of the function.
Request Body
Response Syntax
HTTP/1.1 200
{
"Code": {
"Location": "string",
"RepositoryType": "string"
},
"Concurrency": {
"ReservedConcurrentExecutions": number
559
GetFunction
},
"Configuration": {
"CodeSize": number,
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
},
"Tags": {
"string" : "string"
}
}
Response Elements
560
GetFunction
Code (p. 559)
The deployment package of the function or version.
Type: FunctionCodeLocation (p. 697) object

Concurrency (p. 559)
The function's reserved concurrency.
Type: Concurrency (p. 686) object

Configuration (p. 559)
The configuration of the function or version.
Type: FunctionConfiguration (p. 698) object

Tags (p. 559)
The function's tags.
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
561
GetFunction

562
GetFunctionConcurrency
Returns details about the reserved concurrency configuration for a function. To set a concurrency limit for a
function, use PutFunctionConcurrency (p. 631).
Request Syntax
GET /2019-09-30/functions/FunctionName/concurrency HTTP/1.1

Name formats
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
}
Response Elements
ReservedConcurrentExecutions (p. 563)
The number of simultaneous executions that are reserved for the function.
563
Type: Integer
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
564
GetFunctionConfiguration
Returns the version-specific settings of a Lambda function or version. The output includes
only options that can vary between versions of a function. To modify these settings, use
UpdateFunctionConfiguration (p. 667).
To get all of a function's details, including function-level settings, use GetFunction (p. 559).
Request Syntax
GET /2015-03-31/functions/FunctionName/configuration?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 565)
Specify a version or alias to get details about a published version of the function.
Request Body
Response Syntax
HTTP/1.1 200
{
"CodeSize": number,
565
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
Response Elements
CodeSha256 (p. 565)
Type: String
566
CodeSize (p. 565)
Type: Long

Type: String



Type: String
Type: String
Handler (p. 565)
Type: String
Pattern: [^\s]+
KMSKeyArn (p. 565)
567
Type: String
DDThh:mm:ss.sTZD).
Type: String
Type: String

Type: String
Type: String

Layers (p. 565)

MasterArn (p. 565)
Type: String
MemorySize (p. 565)
Type: Integer

RevisionId (p. 565)
Type: String
Role (p. 565)
568
Type: String
Runtime (p. 565)
Type: String

State (p. 565)
invoking it.
Type: String

Type: String
Type: String

Timeout (p. 565)
Type: Integer


Version (p. 565)
Type: String
VpcConfig (p. 565)
569
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
570
GetFunctionEventInvokeConfig
Retrieves the configuration for asynchronous invocation for a function, version, or alias.
Request Syntax
GET /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 571)
Request Body
Response Syntax
HTTP/1.1 200
{
"OnFailure": {
},
"OnSuccess": {
571
}
},
"MaximumEventAgeInSeconds": number,
"MaximumRetryAttempts": number
}
Response Elements
A destination for events after they have been sent to a function for processing.
Destinations
• Function - The Amazon Resource Name (ARN) of a Lambda function.
• Queue - The ARN of an SQS queue.
• Topic - The ARN of an SNS topic.
• Event Bus - The ARN of an Amazon EventBridge event bus.

The Amazon Resource Name (ARN) of the function.
Type: String
The date and time that the configuration was last updated, in Unix time seconds.
Type: Timestamp
MaximumEventAgeInSeconds (p. 571)
The maximum age of a request that Lambda sends to a function for processing.
Type: Integer

The maximum number of times to retry when the function returns an error.
Type: Integer
Errors
572


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
573
GetLayerVersion
GetLayerVersion
Returns information about a version of an AWS Lambda layer, with a link to download the layer archive
that's valid for 10 minutes.
Request Syntax
GET /2018-10-31/layers/LayerName/versions/VersionNumber HTTP/1.1

LayerName (p. 574)
[a-zA-Z0-9-_]+
Required: Yes
The version number.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"CompatibleRuntimes": [ "string" ],
"Content": {
"CodeSize": number,
"Location": "string"
},
"CreatedDate": "string",
"LayerArn": "string",
"LayerVersionArn": "string",
"LicenseInfo": "string",
"Version": number
}
Response Elements
574
GetLayerVersion
CompatibleRuntimes (p. 574)
The layer's compatible runtimes.
Array Members: Maximum number of 5 items.

Content (p. 574)
Details about the layer version.
Type: LayerVersionContentOutput (p. 708) object

CreatedDate (p. 574)
The date that the layer version was created, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD).
Type: String
The description of the version.
Type: String

LayerArn (p. 574)
The ARN of the layer.
Type: String
Pattern: arn:[a-zA-Z0-9-]+:lambda:[a-zA-Z0-9-]+:\d{12}:layer:[a-zA-Z0-9-_]+
LayerVersionArn (p. 574)
The ARN of the layer version.
Type: String
[0-9]+
LicenseInfo (p. 574)
The layer's software license.
Type: String

Version (p. 574)
The version number.
575
GetLayerVersion
Type: Long
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
576
Returns information about a version of an AWS Lambda layer, with a link to download the layer archive
that's valid for 10 minutes.
Request Syntax
GET /2018-10-31/layers?find=LayerVersion&Arn=Arn HTTP/1.1

Arn (p. 577)
[0-9]+
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"Content": {
"CodeSize": number,
},
"Version": number
}
Response Elements
577

Content (p. 577)

Type: String
Type: String

LayerArn (p. 577)
Type: String
Type: String
[0-9]+
Type: String

Version (p. 577)
The version number.
Type: Long
578
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
579
GetLayerVersionPolicy
Returns the permission policy for a version of an AWS Lambda layer. For more information, see
AddLayerVersionPermission (p. 506).
Request Syntax
GET /2018-10-31/layers/LayerName/versions/VersionNumber/policy HTTP/1.1

LayerName (p. 580)
[a-zA-Z0-9-_]+
Required: Yes
The version number.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"Policy": "string",
"RevisionId": "string"
}
Response Elements
Policy (p. 580)
The policy document.
Type: String
580
RevisionId (p. 580)
Type: String
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
581
GetPolicy
GetPolicy
Returns the resource-based IAM policy for a function, version, or alias.
Request Syntax
GET /2015-03-31/functions/FunctionName/policy?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 582)
Specify a version or alias to get the policy for that resource.
Request Body
Response Syntax
HTTP/1.1 200
{
"Policy": "string",
}
Response Elements
582
GetPolicy
Policy (p. 582)
The resource-based policy.
Type: String
RevisionId (p. 582)
Type: String
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
583
GetProvisionedConcurrencyConfig
Retrieves the provisioned concurrency configuration for a function's alias or version.
Request Syntax
GET /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 584)
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"AllocatedProvisionedConcurrentExecutions": number,
"AvailableProvisionedConcurrentExecutions": number,
"RequestedProvisionedConcurrentExecutions": number,
"Status": "string",
584
"StatusReason": "string"
}
Response Elements
AllocatedProvisionedConcurrentExecutions (p. 584)
The amount of provisioned concurrency allocated.
Type: Integer

AvailableProvisionedConcurrentExecutions (p. 584)
The amount of provisioned concurrency available.
Type: Integer

The date and time that a user last updated the configuration, in ISO 8601 format.
Type: String
RequestedProvisionedConcurrentExecutions (p. 584)
The amount of provisioned concurrency requested.
Type: Integer

Status (p. 584)
The status of the allocation process.
Type: String
Valid Values: IN_PROGRESS | READY | FAILED

StatusReason (p. 584)
For failed allocations, the reason that provisioned concurrency could not be allocated.
Type: String
Errors

ProvisionedConcurrencyConfigNotFoundException
The specified configuration does not exist.
585


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
586
Invoke
Invoke
Invokes a Lambda function. You can invoke a function synchronously (and wait for the response), or
asynchronously. To invoke a function asynchronously, set InvocationType to Event.
For synchronous invocation, details about the function response, including errors, are included in the
response body and headers. For either invocation type, you can find more information in the execution log
and trace.
When an error occurs, your function may be invoked multiple times. Retry behavior varies by error type,
client, event source, and invocation type. For example, if you invoke a function asynchronously and it
returns an error, Lambda executes the function up to two more times. For more information, see Retry
Behavior.
For asynchronous invocation, Lambda adds events to a queue before sending them to your function. If your
function does not have enough capacity to keep up with the queue, events may be lost. Occasionally, your
function may receive the same event multiple times, even if no error occurs. To retain events that were not
processed, configure your function with a dead-letter queue.
The status code in the API response doesn't reflect function errors. Error codes are reserved
for errors that prevent your function from executing, such as permissions errors, limit
errors, or issues with your function's code and configuration. For example, Lambda returns
TooManyRequestsException if executing the function would cause you to exceed a concurrency
limit at either the account level (ConcurrentInvocationLimitExceeded) or function level
(ReservedFunctionConcurrentInvocationLimitExceeded).
For functions with a long timeout, your client might be disconnected during synchronous invocation while it
waits for a response. Configure your HTTP client, SDK, firewall, proxy, or operating system to allow for long
connections with timeout or keep-alive settings.
This operation requires permission for the lambda:InvokeFunction action.
Request Syntax
POST /2015-03-31/functions/FunctionName/invocations?Qualifier=Qualifier HTTP/1.1
X-Amz-Invocation-Type: InvocationType
X-Amz-Log-Type: LogType
X-Amz-Client-Context: ClientContext
Payload

ClientContext (p. 587)
Up to 3583 bytes of base64-encoded data about the invoking client to pass to the function in the
context object.
Name formats
587
Invoke
Required: Yes
InvocationType (p. 587)
Choose from the following options.

• RequestResponse (default) - Invoke the function synchronously. Keep the connection open until
the function returns a response or times out. The API response includes the function response and
additional data.
• Event - Invoke the function asynchronously. Send events that fail multiple times to the function's
dead-letter queue (if it's configured). The API response only includes a status code.
• DryRun - Validate parameter values and verify that the user or role has permission to invoke the
function.
Valid Values: Event | RequestResponse | DryRun

LogType (p. 587)
Set to Tail to include the execution log in the response.
Valid Values: None | Tail

Qualifier (p. 587)
Specify a version or alias to invoke a published version of the function.
Request Body
The request accepts the following binary data.
Payload (p. 587)
The JSON that you want to provide to your Lambda function as input.
Response Syntax
HTTP/1.1 StatusCode
X-Amz-Function-Error: FunctionError
X-Amz-Log-Result: LogResult
X-Amz-Executed-Version: ExecutedVersion
Payload
Response Elements
If the action is successful, the service sends back the following HTTP response.
588
Invoke
StatusCode (p. 588)
The HTTP status code is in the 200 range for a successful request. For the RequestResponse
invocation type, this status code is 200. For the Event invocation type, this status code is 202. For the
DryRun invocation type, the status code is 204.
The response returns the following HTTP headers.
ExecutedVersion (p. 588)
The version of the function that executed. When you invoke a function with an alias, this indicates
which version the alias resolved to.
FunctionError (p. 588)
If present, indicates that an error occurred during function execution. Details about the error are
included in the response payload.
LogResult (p. 588)
The last 4 KB of the execution log, which is base64 encoded.
The response returns the following as the HTTP body.
Payload (p. 588)
The response from the function, or an error object.
Errors
EC2AccessDeniedException
Need additional permissions to configure VPC settings.

EC2ThrottledException
AWS Lambda was throttled by Amazon EC2 during Lambda function initialization using the execution
role provided for the Lambda function.

EC2UnexpectedException
AWS Lambda received an unexpected EC2 client exception while setting up for the Lambda function.

EFSIOException
An error occured when reading from or writing to a connected file system.

EFSMountConnectivityException
The function couldn't make a network connection to the configured file system.
589
Invoke

EFSMountFailureException
The function couldn't mount the configured file system due to a permission or configuration issue.

EFSMountTimeoutException
The function was able to make a network connection to the configured file system, but the mount
operation timed out.

ENILimitReachedException
AWS Lambda was not able to create an elastic network interface in the VPC, specified as part of
Lambda function configuration, because the limit for network interfaces has been reached.


InvalidRequestContentException
The request body could not be parsed as JSON.

InvalidRuntimeException
The runtime or runtime version specified is not supported.

InvalidSecurityGroupIDException
The Security Group ID provided in the Lambda function VPC configuration is invalid.

InvalidSubnetIDException
The Subnet ID provided in the Lambda function VPC configuration is invalid.

InvalidZipFileException
AWS Lambda could not unzip the deployment package.

KMSAccessDeniedException
Lambda was unable to decrypt the environment variables because KMS access was denied. Check the
Lambda function's KMS permissions.

KMSDisabledException
Lambda was unable to decrypt the environment variables because the KMS key used is disabled.
Check the Lambda function's KMS key settings.
590
Invoke

KMSInvalidStateException
Lambda was unable to decrypt the environment variables because the KMS key used is in an invalid
state for Decrypt. Check the function's KMS key settings.

KMSNotFoundException
Lambda was unable to decrypt the environment variables because the KMS key was not found. Check
the function's KMS key settings.

RequestTooLargeException
The request payload exceeded the Invoke request body JSON input limit. For more information, see
Limits.



ResourceNotReadyException
The function is inactive and its VPC connection is no longer available. Wait for the VPC connection to
reestablish and try again.

ServiceException

SubnetIPAddressLimitReachedException
AWS Lambda was not able to set up VPC access for the Lambda function because one or more
configured subnets has no available IP addresses.


UnsupportedMediaTypeException
The content type of the Invoke request body is not JSON.
591
Invoke
See Also

• AWS SDK for C++
• AWS SDK for Go
592
InvokeAsync
InvokeAsync
This action has been deprecated.
Important
For asynchronous function invocation, use Invoke (p. 587).
Invokes a function asynchronously.
Request Syntax
POST /2014-11-13/functions/FunctionName/invoke-async/ HTTP/1.1
InvokeArgs

Name formats
Required: Yes
Request Body
The request accepts the following binary data.
InvokeArgs (p. 593)
The JSON that you want to provide to your Lambda function as input.
Required: Yes
Response Syntax
HTTP/1.1 Status
593
InvokeAsync
Response Elements
If the action is successful, the service sends back the following HTTP response.
Status (p. 593)
The status code.
Errors
InvalidRequestContentException
The request body could not be parsed as JSON.

InvalidRuntimeException
The runtime or runtime version specified is not supported.



ServiceException
See Also

• AWS SDK for C++
• AWS SDK for Go
594
ListAliases
ListAliases
Returns a list of aliases for a Lambda function.
Request Syntax
GET /2015-03-31/functions/FunctionName/aliases?
FunctionVersion=FunctionVersion&Marker=Marker&MaxItems=MaxItems HTTP/1.1

Name formats
Required: Yes
Specify a function version to only list aliases that invoke that version.
Marker (p. 595)
Specify the pagination token that's returned by a previous request to retrieve the next page of results.
MaxItems (p. 595)
Limit the number of aliases returned.
Request Body
Response Syntax
HTTP/1.1 200
595
ListAliases
{
"Aliases": [
{
"Name": "string",
"RoutingConfig": {
"string" : number
}
}
}
],
"NextMarker": "string"
}
Response Elements
Aliases (p. 595)
A list of aliases.
Type: Array of AliasConfiguration (p. 683) objects

NextMarker (p. 595)
The pagination token that's included if more results are available.
Type: String
Errors


ServiceException

596
ListAliases
See Also

• AWS SDK for C++
• AWS SDK for Go
597
ListEventSourceMappings
Lists event source mappings. Specify an EventSourceArn to only show event source mappings for a
single event source.
Request Syntax
GET /2015-03-31/event-source-mappings/?
EventSourceArn=EventSourceArn&FunctionName=FunctionName&Marker=Marker&MaxItems=MaxItems
HTTP/1.1


• Amazon Kinesis - The ARN of the data stream or a stream consumer.
• Amazon DynamoDB Streams - The ARN of the stream.
• Amazon Simple Queue Service - The ARN of the queue.
• Amazon Managed Streaming for Apache Kafka - The ARN of the cluster.
\d{1})?:(\d{12})?:(.*)
Name formats
Marker (p. 598)
A pagination token returned by a previous call.

MaxItems (p. 598)
The maximum number of event source mappings to return.
Request Body
598
Response Syntax
HTTP/1.1 200
{
"EventSourceMappings": [
{
"OnFailure": {
},
"OnSuccess": {
}
},
"State": "string",
"UUID": "string"
}
],
}
Response Elements
EventSourceMappings (p. 599)
A list of event source mappings.
Type: Array of EventSourceMappingConfiguration (p. 692) objects

NextMarker (p. 599)
A pagination token that's returned when the response doesn't contain all event source mappings.
Type: String
Errors
599

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
600
ListFunctionEventInvokeConfigs
Retrieves a list of configurations for asynchronous invocation for a function.
Request Syntax
GET /2019-09-25/functions/FunctionName/event-invoke-config/list?
Marker=Marker&MaxItems=MaxItems HTTP/1.1

Name formats
Required: Yes
Marker (p. 601)
MaxItems (p. 601)
The maximum number of configurations to return.
Request Body
Response Syntax
HTTP/1.1 200
{
"FunctionEventInvokeConfigs": [
{
"OnFailure": {
601
},
"OnSuccess": {
}
},
}
],
}
Response Elements
FunctionEventInvokeConfigs (p. 601)
A list of configurations.
Type: Array of FunctionEventInvokeConfig (p. 703) objects

NextMarker (p. 601)
Type: String
Errors


ServiceException

See Also
602

• AWS SDK for C++
• AWS SDK for Go
603
ListFunctions
ListFunctions
Returns a list of Lambda functions, with the version-specific configuration of each. Lambda returns up to 50
functions per call.
Set FunctionVersion to ALL to include all published versions of each function in addition to the
unpublished version. To get more information about a function or version, use GetFunction (p. 559).
Request Syntax
GET /2015-03-31/functions/?
FunctionVersion=FunctionVersion&Marker=Marker&MasterRegion=MasterRegion&MaxItems=MaxItems
HTTP/1.1

Set to ALL to include entries for all published versions of each function.
Valid Values: ALL

Marker (p. 604)
MasterRegion (p. 604)
For Lambda@Edge functions, the AWS Region of the master function. For example, us-east-1 filters
the list of functions to only include Lambda@Edge functions replicated from a master function in US
East (N. Virginia). If specified, you must set FunctionVersion to ALL.
Pattern: ALL|[a-z]{2}(-gov)?-[a-z]+-\d{1}
MaxItems (p. 604)
The maximum number of functions to return.
Request Body
Response Syntax
HTTP/1.1 200
{
"Functions": [
{
"CodeSize": number,
},
604
ListFunctions
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
],
}
Response Elements
Functions (p. 604)
A list of Lambda functions.
Type: Array of FunctionConfiguration (p. 698) objects
605
ListFunctions
NextMarker (p. 604)
Type: String
Errors

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
606
ListLayers
ListLayers
Lists AWS Lambda layers and shows information about the latest version of each. Specify a runtime
identifier to list only layers that indicate that they're compatible with that runtime.
Request Syntax
GET /2018-10-31/layers?CompatibleRuntime=CompatibleRuntime&Marker=Marker&MaxItems=MaxItems
HTTP/1.1

CompatibleRuntime (p. 607)
A runtime identifier. For example, go1.x.

Marker (p. 607)

MaxItems (p. 607)
The maximum number of layers to return.
Request Body
Response Syntax
HTTP/1.1 200
{
"Layers": [
{
"LatestMatchingVersion": {
"Version": number
},
"LayerName": "string"
}
],
607
ListLayers
Response Elements
Layers (p. 607)
A list of function layers.
Type: Array of LayersListItem (p. 706) objects

NextMarker (p. 607)
A pagination token returned when the response doesn't contain all layers.
Type: String
Errors

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
608
ListLayerVersions
ListLayerVersions
Lists the versions of an AWS Lambda layer. Versions that have been deleted aren't listed. Specify a
runtime identifier to list only versions that indicate that they're compatible with that runtime.
Request Syntax
GET /2018-10-31/layers/LayerName/versions?
CompatibleRuntime=CompatibleRuntime&Marker=Marker&MaxItems=MaxItems HTTP/1.1

CompatibleRuntime (p. 609)
A runtime identifier. For example, go1.x.

LayerName (p. 609)
[a-zA-Z0-9-_]+
Required: Yes
Marker (p. 609)

MaxItems (p. 609)
The maximum number of versions to return.
Request Body
Response Syntax
HTTP/1.1 200
{
"LayerVersions": [
{
609
ListLayerVersions
"Version": number
}
],
}
Response Elements
LayerVersions (p. 609)
A list of versions.
Type: Array of LayerVersionsListItem (p. 709) objects

NextMarker (p. 609)
A pagination token returned when the response doesn't contain all versions.
Type: String
Errors


ServiceException

See Also

• AWS SDK for C++
610
ListLayerVersions
• AWS SDK for Go

611
ListProvisionedConcurrencyConfigs
Retrieves a list of provisioned concurrency configurations for a function.
Request Syntax
GET /2019-09-30/functions/FunctionName/provisioned-concurrency?
List=ALL&Marker=Marker&MaxItems=MaxItems HTTP/1.1

Name formats
Required: Yes
Marker (p. 612)
MaxItems (p. 612)
Specify a number to limit the number of configurations returned.
Request Body
Response Syntax
HTTP/1.1 200
{
"NextMarker": "string",
"ProvisionedConcurrencyConfigs": [
{
612
"Status": "string",
}
]
}
Response Elements
NextMarker (p. 612)
Type: String
ProvisionedConcurrencyConfigs (p. 612)
A list of provisioned concurrency configurations.
Type: Array of ProvisionedConcurrencyConfigListItem (p. 713) objects
Errors


ServiceException

See Also

• AWS SDK for C++
613
• AWS SDK for Go

614
ListTags
ListTags
Returns a function's tags. You can also view tags with GetFunction (p. 559).
Request Syntax
GET /2017-03-31/tags/ARN HTTP/1.1

ARN (p. 615)
Required: Yes
Request Body
Response Syntax
HTTP/1.1 200
{
"Tags": {
"string" : "string"
}
}
Response Elements
Tags (p. 615)
The function's tags.
Errors
615
ListTags


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
616
ListVersionsByFunction
Returns a list of versions, with the version-specific configuration of each. Lambda returns up to 50 versions
per call.
Request Syntax
GET /2015-03-31/functions/FunctionName/versions?Marker=Marker&MaxItems=MaxItems HTTP/1.1

Name formats
Required: Yes
Marker (p. 617)
MaxItems (p. 617)
The maximum number of versions to return.
Request Body
Response Syntax
HTTP/1.1 200
{
"NextMarker": "string",
"Versions": [
{
"CodeSize": number,
617
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
]
}
Response Elements
NextMarker (p. 617)
618
Type: String
Versions (p. 617)
A list of Lambda function versions.
Type: Array of FunctionConfiguration (p. 698) objects
Errors


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
619
PublishLayerVersion
PublishLayerVersion
Creates an AWS Lambda layer from a ZIP archive. Each time you call PublishLayerVersion with the
same layer name, a new version is created.
Add layers to your function with CreateFunction (p. 524) or UpdateFunctionConfiguration (p. 667).
Request Syntax
POST /2018-10-31/layers/LayerName/versions HTTP/1.1
{
"Content": {
"S3Key": "string",
"ZipFile": blob
},
"LicenseInfo": "string"
}

LayerName (p. 620)
[a-zA-Z0-9-_]+
Required: Yes
Request Body
A list of compatible function runtimes. Used for filtering with ListLayers (p. 607) and
ListLayerVersions (p. 609).

620
PublishLayerVersion
Required: No
Content (p. 620)
The function layer archive.
Type: LayerVersionContentInput (p. 707) object
Required: Yes
Type: String
Required: No
The layer's software license. It can be any of the following:

• An SPDX license identifier. For example, MIT.
• The URL of a license hosted on the internet. For example, https://opensource.org/
licenses/MIT.
• The full text of the license.
Type: String
Required: No
Response Syntax
HTTP/1.1 201
{
"Content": {
"CodeSize": number,
},
"Version": number
}
Response Elements
621
PublishLayerVersion

Content (p. 621)

Type: String
Type: String

LayerArn (p. 621)
Type: String
Type: String
[0-9]+
Type: String

Version (p. 621)
The version number.
Type: Long
622
PublishLayerVersion
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
623
PublishVersion
PublishVersion
Creates a version from the current code and configuration of a function. Use versions to create a snapshot
of your function code and configuration that doesn't change.
AWS Lambda doesn't publish a version if the function's configuration and code haven't changed since the
last version. Use UpdateFunctionCode (p. 659) or UpdateFunctionConfiguration (p. 667) to update the
function before publishing a version.
Clients can invoke versions directly or with an alias. To create an alias, use CreateAlias (p. 513).
Request Syntax
POST /2015-03-31/functions/FunctionName/versions HTTP/1.1
{
}

Name formats
Required: Yes
Request Body
CodeSha256 (p. 624)
Only publish a version if the hash value matches the value that's specified. Use this option to avoid
publishing a version if the function code has changed since you last updated it. You can get the hash
for the version that you uploaded from the output of UpdateFunctionCode (p. 659).
Type: String
624
PublishVersion
Required: No
A description for the version to override the description in the function configuration.
Type: String
Required: No
RevisionId (p. 624)
Only update the function if the revision ID matches the ID that's specified. Use this option to avoid
publishing a version if the function configuration has changed since you last updated it.
Type: String
Required: No
Response Syntax
HTTP/1.1 201
{
"CodeSize": number,
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
625
PublishVersion
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
Response Elements
CodeSha256 (p. 625)
Type: String
CodeSize (p. 625)
Type: Long

Type: String



626
PublishVersion
Type: String
Type: String
Handler (p. 625)
Type: String
Pattern: [^\s]+
KMSKeyArn (p. 625)
Type: String
DDThh:mm:ss.sTZD).
Type: String
Type: String

Type: String
Type: String

627
PublishVersion
Layers (p. 625)

MasterArn (p. 625)
Type: String
MemorySize (p. 625)
Type: Integer

RevisionId (p. 625)
Type: String
Role (p. 625)
Type: String
Runtime (p. 625)
Type: String

State (p. 625)
invoking it.
Type: String

Type: String
628
PublishVersion
Type: String

Timeout (p. 625)
Type: Integer


Version (p. 625)
Type: String
VpcConfig (p. 625)
Errors




629
PublishVersion

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
630
PutFunctionConcurrency
Sets the maximum number of simultaneous executions for a function, and reserves capacity for that
concurrency level.
Concurrency settings apply to the function as a whole, including all published versions and the unpublished
version. Reserving concurrency both ensures that your function has capacity to process the specified
number of events simultaneously, and prevents it from scaling beyond that level. Use GetFunction (p. 559)
to see the current setting for a function.
Use GetAccountSettings (p. 550) to see your Regional concurrency limit. You can reserve concurrency for
as many functions as you like, as long as you leave at least 100 simultaneous executions unreserved for
functions that aren't configured with a per-function limit. For more information, see Managing Concurrency.
Request Syntax
PUT /2017-10-31/functions/FunctionName/concurrency HTTP/1.1
{
}

Name formats
Required: Yes
Request Body
The number of simultaneous executions to reserve for the function.
Type: Integer
631
Required: Yes
Response Syntax
HTTP/1.1 200
{
}
Response Elements
The number of concurrent executions that are reserved for this function. For more information, see
Managing Concurrency.
Type: Integer
Errors



ServiceException

632
See Also

• AWS SDK for C++
• AWS SDK for Go
633
PutFunctionEventInvokeConfig
Configures options for asynchronous invocation on a function, version, or alias. If a configuration
already exists for a function, version, or alias, this operation overwrites it. If you exclude any settings,
they are removed. To set one option without affecting existing settings for other options, use
UpdateFunctionEventInvokeConfig (p. 676).
By default, Lambda retries an asynchronous invocation twice if the function returns an error. It retains
events in a queue for up to six hours. When an event fails all processing attempts or stays in the
asynchronous invocation queue for too long, Lambda discards it. To retain discarded events, configure a
dead-letter queue with UpdateFunctionConfiguration (p. 667).
To send an invocation record to a queue, topic, function, or event bus, specify a destination. You can
configure separate destinations for successful invocations (on-success) and events that fail all processing
attempts (on-failure). You can configure destinations in addition to or instead of a dead-letter queue.
Request Syntax
PUT /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1
{
"OnFailure": {
},
"OnSuccess": {
}
},
}

Name formats
Required: Yes
634
Qualifier (p. 634)
Request Body
Destinations
Required: No
Type: Integer
Required: No
Type: Integer
Required: No
Response Syntax
HTTP/1.1 200
{
"OnFailure": {
},
"OnSuccess": {
}
635
},
}
Response Elements
Destinations

Type: String
Type: Timestamp
Type: Integer

Type: Integer
Errors
636


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
637
PutProvisionedConcurrencyConfig
Adds a provisioned concurrency configuration to a function's alias or version.
Request Syntax
PUT /2019-09-30/functions/FunctionName/provisioned-concurrency?Qualifier=Qualifier HTTP/1.1
{
"ProvisionedConcurrentExecutions": number
}

Name formats
Required: Yes
Qualifier (p. 638)
Required: Yes
Request Body
ProvisionedConcurrentExecutions (p. 638)
The amount of provisioned concurrency to allocate for the version or alias.
Type: Integer
638
Required: Yes
Response Syntax
HTTP/1.1 202
{
"Status": "string",
}
Response Elements
AllocatedProvisionedConcurrentExecutions (p. 639)
Type: Integer

AvailableProvisionedConcurrentExecutions (p. 639)
Type: Integer

Type: String
RequestedProvisionedConcurrentExecutions (p. 639)
Type: Integer

Status (p. 639)
Type: String

StatusReason (p. 639)
639
Type: String
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
640
RemoveLayerVersionPermission
Removes a statement from the permissions policy for a version of an AWS Lambda layer. For more
information, see AddLayerVersionPermission (p. 506).
Request Syntax
DELETE /2018-10-31/layers/LayerName/versions/VersionNumber/policy/StatementId?
RevisionId=RevisionId HTTP/1.1

LayerName (p. 641)
[a-zA-Z0-9-_]+
Required: Yes
RevisionId (p. 641)
Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a
policy that has changed since you last read it.
The identifier that was specified when the statement was added.
Required: Yes
The version number.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
641
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
642
RemovePermission
RemovePermission
Revokes function-use permission from an AWS service or another account. You can get the ID of the
statement from the output of GetPolicy (p. 582).
Request Syntax
DELETE /2015-03-31/functions/FunctionName/policy/StatementId?
Qualifier=Qualifier&RevisionId=RevisionId HTTP/1.1

Name formats
Required: Yes
Qualifier (p. 643)
Specify a version or alias to remove permissions from a published version of the function.
RevisionId (p. 643)
Only update the policy if the revision ID matches the ID that's specified. Use this option to avoid
modifying a policy that has changed since you last read it.
Statement ID of the permission to remove.
Pattern: ([a-zA-Z0-9-_.]+)
Required: Yes
Request Body
643
RemovePermission
Response Syntax
HTTP/1.1 204
Response Elements
Errors



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
644
TagResource
TagResource
Adds tags to a function.
Request Syntax
POST /2017-03-31/tags/ARN HTTP/1.1
{
"Tags": {
"string" : "string"
}
}

ARN (p. 645)
Required: Yes
Request Body
Tags (p. 645)
A list of tags to apply to the function.
Required: Yes
Response Syntax
HTTP/1.1 204
Response Elements
Errors
645
TagResource



ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
646
UntagResource
UntagResource
Removes tags from a function.
Request Syntax
DELETE /2017-03-31/tags/ARN?tagKeys=TagKeys HTTP/1.1

ARN (p. 647)
Required: Yes
TagKeys (p. 647)
A list of tag keys to remove from the function.
Required: Yes
Request Body
Response Syntax
HTTP/1.1 204
Response Elements
Errors


647
UntagResource

ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
648
UpdateAlias
UpdateAlias
Updates the configuration of a Lambda function alias.
Request Syntax
PUT /2015-03-31/functions/FunctionName/aliases/Name HTTP/1.1
{
"RoutingConfig": {
"string" : number
}
}
}

Name formats
Required: Yes
Name (p. 649)
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
Required: Yes
Request Body
649
UpdateAlias
Type: String
Required: No
Type: String
Required: No
RevisionId (p. 649)
Only update the alias if the revision ID matches the ID that's specified. Use this option to avoid
modifying an alias that has changed since you last read it.
Type: String
Required: No
Required: No
Response Syntax
HTTP/1.1 200
{
"Name": "string",
"RoutingConfig": {
"string" : number
}
}
}
Response Elements
650
UpdateAlias
AliasArn (p. 650)
Type: String
Type: String

Type: String
Name (p. 650)
Type: String
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
RevisionId (p. 650)
Type: String
Errors

651
UpdateAlias


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
652
UpdateEventSourceMapping
Updates an event source mapping. You can change the function that AWS Lambda invokes, or pause
invocation and resume later from the same location.
The following error handling options are only available for stream sources (DynamoDB and Kinesis):
• BisectBatchOnFunctionError - If the function returns an error, split the batch in two and retry.
• DestinationConfig - Send discarded records to an Amazon SQS queue or Amazon SNS topic.
• MaximumRecordAgeInSeconds - Discard records older than the specified age. Default -1 (infinite).
Minimum 60. Maximum 604800.
• MaximumRetryAttempts - Discard records after the specified number of retries. Default -1 (infinite).
Minimum 0. Maximum 10000. When infinite, failed records will be retried until the record expires.
• ParallelizationFactor - Process multiple batches from each shard concurrently.
Request Syntax
PUT /2015-03-31/event-source-mappings/UUID HTTP/1.1
{
"OnFailure": {
},
"OnSuccess": {
}
},
"Enabled": boolean,
"ParallelizationFactor": number
}

UUID (p. 653)
Required: Yes
Request Body
BatchSize (p. 653)
653
• Amazon Kinesis - Default 100. Max 10,000.

• Amazon DynamoDB Streams - Default 100. Max 1,000.
• Amazon Simple Queue Service - Default 10. Max 10.
• Amazon Managed Streaming for Apache Kafka - Default 100. Max 10,000.
Type: Integer
Required: No
Type: Boolean
Required: No
Required: No
Enabled (p. 653)
If true, the event source mapping is active. Set to false to pause polling and invocation.
Type: Boolean
Required: No
Name formats
Type: String
Required: No
654
Type: Integer
Required: No
(Streams) Discard records older than the specified age. The default value is infinite (-1).
Type: Integer
Required: No
(Streams) Discard records after the specified number of retries. The default value is infinite (-1). When
set to infinite (-1), failed records will be retried until the record expires.
Type: Integer
Required: No
Type: Integer
Required: No
Response Syntax
HTTP/1.1 202
{
"OnFailure": {
},
"OnSuccess": {
}
},
"State": "string",
655
"UUID": "string"
}
Response Elements
BatchSize (p. 655)
Type: Integer

Type: Boolean

Type: String
\d{1})?:(\d{12})?:(.*)
Type: String
Type: Timestamp
Type: String
Type: Integer
656

Type: Integer

Type: Integer

Type: Integer

State (p. 655)
Type: String
service.
Type: String
Topics (p. 655)
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
UUID (p. 655)
Type: String
Errors
657

ResourceInUseException
The operation conflicts with the resource's availability. For example, you attempted to update an
EventSource Mapping in CREATING, or tried to delete a EventSource mapping currently in the
UPDATING state.


ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
658
UpdateFunctionCode
UpdateFunctionCode
Updates a Lambda function's code.
The function's code is locked when you publish a version. You can't modify the code of a published version,
only the unpublished version.
Request Syntax
PUT /2015-03-31/functions/FunctionName/code HTTP/1.1
{
"DryRun": boolean,
"Publish": boolean,
"S3Key": "string",
"ZipFile": blob
}

Name formats
Required: Yes
Request Body
DryRun (p. 659)
Set to true to validate the request parameters and access permissions without modifying the function
code.
Type: Boolean
Required: No
659
UpdateFunctionCode
Publish (p. 659)
Set to true to publish a new version of the function after updating the code. This has the same effect as
calling PublishVersion (p. 624) separately.
Type: Boolean
Required: No
RevisionId (p. 659)
modifying a function that has changed since you last read it.
Type: String
Required: No
S3Bucket (p. 659)
An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different
AWS account.
Type: String
Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$
Required: No
S3Key (p. 659)
The Amazon S3 key of the deployment package.
Type: String
Required: No
S3ObjectVersion (p. 659)
For versioned objects, the version of the deployment package object to use.
Type: String
Required: No
ZipFile (p. 659)
The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the
encoding for you.
Type: Base64-encoded binary data object
Required: No
Response Syntax
HTTP/1.1 200
660
UpdateFunctionCode
"CodeSize": number,
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
Response Elements
CodeSha256 (p. 660)
661
UpdateFunctionCode
Type: String
CodeSize (p. 660)
Type: Long

Type: String



Type: String
Type: String
Handler (p. 660)
Type: String
Pattern: [^\s]+
662
UpdateFunctionCode
KMSKeyArn (p. 660)
Type: String
DDThh:mm:ss.sTZD).
Type: String
Type: String

Type: String
Type: String

Layers (p. 660)

MasterArn (p. 660)
Type: String
MemorySize (p. 660)
Type: Integer

RevisionId (p. 660)
663
UpdateFunctionCode
Type: String
Role (p. 660)
Type: String
Runtime (p. 660)
Type: String

State (p. 660)
invoking it.
Type: String

Type: String
Type: String

Timeout (p. 660)
Type: Integer


Version (p. 660)
Type: String
664
UpdateFunctionCode
VpcConfig (p. 660)
Errors





ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
665
UpdateFunctionCode

666
Modify the version-specific settings of a Lambda function.
When you update a function, Lambda provisions an instance of the function and its supporting resources.
If your function connects to a VPC, this process can take a minute. During this time, you can't modify
the function, but you can still invoke it. The LastUpdateStatus, LastUpdateStatusReason, and
LastUpdateStatusReasonCode fields in the response from GetFunctionConfiguration (p. 565) indicate
when the update is complete and the function is processing events with the new configuration. For more
information, see Function States.
These settings can vary between versions of a function and are locked when you publish a version. You
can't modify the configuration of a published version, only the unpublished version.
To configure function concurrency, use PutFunctionConcurrency (p. 631). To grant invoke permissions to
an account or AWS service, use AddPermission (p. 509).
Request Syntax
PUT /2015-03-31/functions/FunctionName/configuration HTTP/1.1
{
},
"Environment": {
"Variables": {
"string" : "string"
}
},
{
"Arn": "string",
}
],
"Layers": [ "string" ],
"Role": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"SubnetIds": [ "string" ]
}
}

667
Name formats
Required: Yes
Request Body
A dead letter queue configuration that specifies the queue or topic where Lambda sends asynchronous
events when they fail processing. For more information, see Dead Letter Queues.
Required: No
A description of the function.
Type: String
Required: No
Environment variables that are accessible from function code during execution.
Type: Environment (p. 689) object
Required: No
Required: No
668
Handler (p. 667)
The name of the method within your code that Lambda calls to execute your function. The format
includes the file name. It can also include namespaces and other qualifiers, depending on the runtime.
For more information, see Programming Model.
Type: String
Pattern: [^\s]+
Required: No
KMSKeyArn (p. 667)
The ARN of the AWS Key Management Service (AWS KMS) key that's used to encrypt your function's
environment variables. If it's not provided, AWS Lambda uses a default service key.
Type: String
Required: No
Layers (p. 667)
A list of function layers to add to the function's execution environment. Specify each layer by its ARN,
including the version.
[0-9]+
Required: No
MemorySize (p. 667)
The amount of memory that your function has access to. Increasing the function's memory also
increases its CPU allocation. The default value is 128 MB. The value must be a multiple of 64 MB.
Type: Integer
Required: No
RevisionId (p. 667)
modifying a function that has changed since you last read it.
Type: String
Required: No
Role (p. 667)
The Amazon Resource Name (ARN) of the function's execution role.
Type: String
669
Required: No
Runtime (p. 667)
The identifier of the function's runtime.
Type: String

Required: No
Timeout (p. 667)
The amount of time that Lambda allows a function to run before stopping it. The default is 3 seconds.
The maximum allowed value is 900 seconds.
Type: Integer
Required: No
Set Mode to Active to sample and trace a subset of incoming requests with AWS X-Ray.
Type: TracingConfig (p. 715) object
Required: No
VpcConfig (p. 667)
For network connectivity to AWS resources in a VPC, specify a list of security groups and subnets in
the VPC. When you connect a function to a VPC, it can only access resources and the internet through
that VPC. For more information, see VPC Settings.
Type: VpcConfig (p. 717) object
Required: No
Response Syntax
HTTP/1.1 200
{
"CodeSize": number,
},
"Environment": {
"Error": {
"Message": "string"
},
"Variables": {
"string" : "string"
670
}
},
{
"Arn": "string",
}
],
"Layers": [
{
"Arn": "string",
"CodeSize": number
}
],
"Role": "string",
"State": "string",
"Timeout": number,
"TracingConfig": {
"Mode": "string"
},
"VpcConfig": {
"VpcId": "string"
}
}
Response Elements
CodeSha256 (p. 670)
Type: String
CodeSize (p. 670)
Type: Long
671
Type: String



Type: String
Type: String
Handler (p. 670)
Type: String
Pattern: [^\s]+
KMSKeyArn (p. 670)
Type: String
DDThh:mm:ss.sTZD).
Type: String
672
Type: String

Type: String
Type: String

Layers (p. 670)

MasterArn (p. 670)
Type: String
MemorySize (p. 670)
Type: Integer

RevisionId (p. 670)
Type: String
Role (p. 670)
Type: String
Runtime (p. 670)
Type: String
673

State (p. 670)
invoking it.
Type: String

Type: String
Type: String

Timeout (p. 670)
Type: Integer


Version (p. 670)
Type: String
VpcConfig (p. 670)
Errors
674




ServiceException

See Also

• AWS SDK for C++
• AWS SDK for Go
675
UpdateFunctionEventInvokeConfig
Updates the configuration for asynchronous invocation for a function, version, or alias.
Request Syntax
POST /2019-09-25/functions/FunctionName/event-invoke-config?Qualifier=Qualifier HTTP/1.1
{
"OnFailure": {
},
"OnSuccess": {
}
},
}

Name formats
Required: Yes
Qualifier (p. 676)
Request Body
676
Destinations
Required: No
Type: Integer
Required: No
Type: Integer
Required: No
Response Syntax
HTTP/1.1 200
{
"OnFailure": {
},
"OnSuccess": {
}
},
}
Response Elements
677
Destinations

Type: String
Type: Timestamp
Type: Integer

Type: Integer
Errors


ServiceException
678
Data Types
See Also

• AWS SDK for C++
• AWS SDK for Go
Data Types
The following data types are supported:
• AccountLimit (p. 681)

• AccountUsage (p. 682)
• AliasConfiguration (p. 683)
• AliasRoutingConfiguration (p. 685)
• Concurrency (p. 686)
• DeadLetterConfig (p. 687)
• DestinationConfig (p. 688)
• Environment (p. 689)
• EnvironmentError (p. 690)
• EnvironmentResponse (p. 691)
• EventSourceMappingConfiguration (p. 692)
• FileSystemConfig (p. 695)
• FunctionCode (p. 696)
• FunctionCodeLocation (p. 697)
• FunctionConfiguration (p. 698)
• FunctionEventInvokeConfig (p. 703)
• Layer (p. 705)
• LayersListItem (p. 706)
• LayerVersionContentInput (p. 707)
• LayerVersionContentOutput (p. 708)
• LayerVersionsListItem (p. 709)
• OnFailure (p. 711)
• OnSuccess (p. 712)
679
Data Types
• ProvisionedConcurrencyConfigListItem (p. 713)

• TracingConfig (p. 715)
• TracingConfigResponse (p. 716)
• VpcConfig (p. 717)
• VpcConfigResponse (p. 718)
680
AccountLimit
AccountLimit
Limits that are related to concurrency and storage. All file and storage sizes are in bytes.
Contents
CodeSizeUnzipped
The maximum size of a function's deployment package and layers when they're extracted.
Type: Long
Required: No
CodeSizeZipped
The maximum size of a deployment package when it's uploaded directly to AWS Lambda. Use Amazon
S3 for larger files.
Type: Long
Required: No
ConcurrentExecutions
The maximum number of simultaneous function executions.
Type: Integer
Required: No
TotalCodeSize
The amount of storage space that you can use for all deployment packages and layer archives.
Type: Long
Required: No
UnreservedConcurrentExecutions
The maximum number of simultaneous function executions, minus the capacity that's reserved for
individual functions with PutFunctionConcurrency (p. 631).
Type: Integer
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
681
AccountUsage
AccountUsage
The number of functions and amount of storage in use.
Contents
FunctionCount
The number of Lambda functions.
Type: Long
Required: No
TotalCodeSize
The amount of storage space, in bytes, that's being used by deployment packages and layer archives.
Type: Long
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
682
AliasConfiguration
AliasConfiguration
Provides configuration information about a Lambda function alias.
Contents
AliasArn
Type: String
Required: No
Description
Type: String
Required: No
FunctionVersion
Type: String
Required: No
Name
Type: String
Pattern: (?!^[0-9]+$)([a-zA-Z0-9-_]+)
Required: No
RevisionId
Type: String
Required: No
RoutingConfig
683
AliasConfiguration
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
684
AliasRoutingConfiguration
AliasRoutingConfiguration
The traffic-shifting configuration of a Lambda function alias.
Contents
AdditionalVersionWeights
The second version, and the percentage of traffic that's routed to it.
Type: String to double map
Key Length Constraints: Minimum length of 1. Maximum length of 1024.
Key Pattern: [0-9]+
Valid Range: Minimum value of 0.0. Maximum value of 1.0.
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
685
Concurrency
Concurrency
Contents
ReservedConcurrentExecutions
The number of concurrent executions that are reserved for this function. For more information, see
Managing Concurrency.
Type: Integer
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
686
DeadLetterConfig
DeadLetterConfig
The dead-letter queue for failed asynchronous invocations.
Contents
TargetArn
The Amazon Resource Name (ARN) of an Amazon SQS queue or Amazon SNS topic.
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
687
DestinationConfig
DestinationConfig
A configuration object that specifies the destination of an event after Lambda processes it.
Contents
OnFailure
The destination configuration for failed invocations.
Type: OnFailure (p. 711) object
Required: No
OnSuccess
The destination configuration for successful invocations.
Type: OnSuccess (p. 712) object
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
688
Environment
Environment
A function's environment variable settings.
Contents
Variables
Environment variable key-value pairs.
Key Pattern: [a-zA-Z]([a-zA-Z0-9_])+
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
689
EnvironmentError
EnvironmentError
Error messages for environment variables that couldn't be applied.
Contents
ErrorCode
The error code.
Type: String
Required: No
Message
The error message.
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
690
EnvironmentResponse
EnvironmentResponse
The results of an operation to update or read environment variables. If the operation is successful, the
response contains the environment variables. If it failed, the response contains details about the error.
Contents
Error
Error messages for environment variables that couldn't be applied.
Type: EnvironmentError (p. 690) object
Required: No
Variables
Environment variable key-value pairs.
Key Pattern: [a-zA-Z]([a-zA-Z0-9_])+
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
691
EventSourceMappingConfiguration
A mapping between an AWS resource and an AWS Lambda function. See
CreateEventSourceMapping (p. 517) for details.
Contents
BatchSize
Type: Integer
Required: No
BisectBatchOnFunctionError
Type: Boolean
Required: No
DestinationConfig
Required: No
EventSourceArn
Type: String
\d{1})?:(\d{12})?:(.*)
Required: No
FunctionArn
Type: String
Required: No
LastModified
Type: Timestamp
Required: No
692
LastProcessingResult
Type: String
Required: No
MaximumBatchingWindowInSeconds
Type: Integer
Required: No
MaximumRecordAgeInSeconds
Type: Integer
Required: No
MaximumRetryAttempts
Type: Integer
Required: No
ParallelizationFactor
Type: Integer
Required: No
State
Type: String
Required: No
StateTransitionReason
service.
Type: String
Required: No
693
Topics
Pattern: ^[^.]([a-zA-Z0-9\-_.]+)
Required: No
UUID
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
694
FileSystemConfig
FileSystemConfig
Details about the connection between a Lambda function and an Amazon EFS file system.
Contents
Arn
The Amazon Resource Name (ARN) of the Amazon EFS access point that provides access to the file
system.
Type: String
Pattern: arn:aws[a-zA-Z-]*:elasticfilesystem:[a-z]{2}((-gov)|(-iso(b?)))?-[a-
z]+-\d{1}:\d{12}:access-point/fsap-[a-f0-9]{17}
Required: Yes
LocalMountPath
The path where the function can access the file system, starting with /mnt/.
Type: String
Pattern: ^/mnt/[a-zA-Z0-9-_.]+$
Required: Yes
See Also
• AWS SDK for C++

• AWS SDK for Go
695
FunctionCode
FunctionCode
The code for the Lambda function. You can specify either an object in Amazon S3, or upload a deployment
package directly.
Contents
S3Bucket
An Amazon S3 bucket in the same AWS Region as your function. The bucket can be in a different
AWS account.
Type: String
Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$
Required: No
S3Key
The Amazon S3 key of the deployment package.
Type: String
Required: No
S3ObjectVersion
For versioned objects, the version of the deployment package object to use.
Type: String
Required: No
ZipFile
The base64-encoded contents of the deployment package. AWS SDK and AWS CLI clients handle the
encoding for you.
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
696
FunctionCodeLocation
FunctionCodeLocation
Details about a function's deployment package.
Contents
Location
A presigned URL that you can use to download the deployment package.
Type: String
Required: No
RepositoryType
The service that's hosting the file.
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
697
FunctionConfiguration
Details about a function's configuration.
Contents
CodeSha256
Type: String
Required: No
CodeSize
Type: Long
Required: No
DeadLetterConfig
Required: No
Description
Type: String
Required: No
Environment
Required: No
FileSystemConfigs
Required: No
FunctionArn
Type: String
698
Required: No
FunctionName
Type: String
Required: No
Handler
Type: String
Pattern: [^\s]+
Required: No
KMSKeyArn
Type: String
Required: No
LastModified
DDThh:mm:ss.sTZD).
Type: String
Required: No
LastUpdateStatus
Type: String
Required: No
LastUpdateStatusReason
Type: String
699
Required: No
LastUpdateStatusReasonCode
Type: String

Required: No
Layers
Required: No
MasterArn
Type: String
Required: No
MemorySize
Type: Integer
Required: No
RevisionId
Type: String
Required: No
Role
Type: String
Required: No
Runtime
Type: String
700

Required: No
State
invoking it.
Type: String
Required: No
StateReason
Type: String
Required: No
StateReasonCode
Type: String

Required: No
Timeout
Type: Integer
Required: No
TracingConfig
Required: No
Version
Type: String
701
Required: No
VpcConfig
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
702
FunctionEventInvokeConfig
Contents
DestinationConfig
Destinations
Required: No
FunctionArn
Type: String
Required: No
LastModified
Type: Timestamp
Required: No
MaximumEventAgeInSeconds
Type: Integer
Required: No
MaximumRetryAttempts
Type: Integer
Required: No
See Also
703
• AWS SDK for C++

• AWS SDK for Go
704
Layer
Layer
An AWS Lambda layer.
Contents
Arn
The Amazon Resource Name (ARN) of the function layer.
Type: String
[0-9]+
Required: No
CodeSize
The size of the layer archive in bytes.
Type: Long
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
705
LayersListItem
LayersListItem
Details about an AWS Lambda layer.
Contents
LatestMatchingVersion
The newest version of the layer.
Type: LayerVersionsListItem (p. 709) object
Required: No
LayerArn
The Amazon Resource Name (ARN) of the function layer.
Type: String
Required: No
LayerName
The name of the layer.
Type: String
[a-zA-Z0-9-_]+
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
706
LayerVersionContentInput
LayerVersionContentInput
A ZIP archive that contains the contents of an AWS Lambda layer. You can specify either an Amazon S3
location, or upload a layer archive directly.
Contents
S3Bucket
The Amazon S3 bucket of the layer archive.
Type: String
Pattern: ^[0-9A-Za-z\.\-_]*(?<!\.)$
Required: No
S3Key
The Amazon S3 key of the layer archive.
Type: String
Required: No
S3ObjectVersion
For versioned objects, the version of the layer archive object to use.
Type: String
Required: No
ZipFile
The base64-encoded contents of the layer archive. AWS SDK and AWS CLI clients handle the
encoding for you.
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
707
LayerVersionContentOutput
LayerVersionContentOutput
Details about a version of an AWS Lambda layer.
Contents
CodeSha256
The SHA-256 hash of the layer archive.
Type: String
Required: No
CodeSize
The size of the layer archive in bytes.
Type: Long
Required: No
Location
A link to the layer archive in Amazon S3 that is valid for 10 minutes.
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
708
LayerVersionsListItem
Details about a version of an AWS Lambda layer.
Contents
CompatibleRuntimes

Required: No
CreatedDate
The date that the version was created, in ISO 8601 format. For example,
2018-11-27T15:10:45.123+0000.
Type: String
Required: No
Description
Type: String
Required: No
LayerVersionArn
Type: String
[0-9]+
Required: No
LicenseInfo
The layer's open-source license.
Type: String
Required: No
709
Version
The version number.
Type: Long
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
710
OnFailure
OnFailure
A destination for events that failed processing.
Contents
Destination
The Amazon Resource Name (ARN) of the destination resource.
Type: String
Pattern: ^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
711
OnSuccess
OnSuccess
A destination for events that were processed successfully.
Contents
Destination
The Amazon Resource Name (ARN) of the destination resource.
Type: String
Pattern: ^$|arn:(aws[a-zA-Z0-9-]*):([a-zA-Z0-9\-])+:([a-z]{2}(-gov)?-[a-z]+-
\d{1})?:(\d{12})?:(.*)
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
712
ProvisionedConcurrencyConfigListItem
Details about the provisioned concurrency configuration for a function alias or version.
Contents
AllocatedProvisionedConcurrentExecutions
Type: Integer
Required: No
AvailableProvisionedConcurrentExecutions
Type: Integer
Required: No
FunctionArn
The Amazon Resource Name (ARN) of the alias or version.
Type: String
Required: No
LastModified
Type: String
Required: No
RequestedProvisionedConcurrentExecutions
Type: Integer
Required: No
Status
Type: String
Required: No
713
StatusReason
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
714
TracingConfig
TracingConfig
The function's AWS X-Ray tracing configuration. To sample and record incoming requests, set Mode to
Active.
Contents
Mode
The tracing mode.
Type: String
Valid Values: Active | PassThrough
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
715
TracingConfigResponse
TracingConfigResponse
Contents
Mode
The tracing mode.
Type: String
Valid Values: Active | PassThrough
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
716
VpcConfig
VpcConfig
The VPC security groups and subnets that are attached to a Lambda function. For more information, see
VPC Settings.
Contents
SecurityGroupIds
A list of VPC security groups IDs.
Required: No
SubnetIds
A list of VPC subnet IDs.
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
717
VpcConfigResponse
VpcConfigResponse
The VPC security groups and subnets that are attached to a Lambda function.
Contents
SecurityGroupIds
A list of VPC security groups IDs.
Required: No
SubnetIds
A list of VPC subnet IDs.
Required: No
VpcId
The ID of the VPC.
Type: String
Required: No
See Also
• AWS SDK for C++

• AWS SDK for Go
Errores de los certificados cuando se utiliza un SDK

Como los SDK de AWS utilizan certificados de CA desde su equipo, los cambios en los certificados en
los servidores de AWS pueden provocar errores de conexión cuando intentar usar un SDK. Puede evitar
estos errores manteniendo actualizados los certificados de CA de su equipo y el sistema operativo. Si
detecta este problema en un entorno corporativo y no administra su propio equipo, es posible que deba
pedir ayuda a un administrador con el proceso de actualización. La siguiente lista muestra las versiones
mínimas necesarias del sistema operativo y Java:
• Las versiones de Microsoft Windows con actualizaciones instaladas a partir de enero de 2005 o fechas
posteriores, contienen al menos uno de los CA necesarios en su lista de confianza.
• Mac OS X 10.4 con Java para Mac OS X 10.4 Release 5 (febrero de 2007), Mac OS X 10.5 (octubre de
2007) y las versiones posteriores contienen al menos uno de los CA necesarios en su lista de confianza.
718
Errores de los certificados cuando se utiliza un SDK
• Red Hat Enterprise Linux 5 (marzo de 2007), 6 y 7 y CentOS 5, 6 y 7 contienen al menos uno de los CA
necesarios en su lista de confianza predeterminada.
• Java 1.4.2_12 (mayo de 2006), 5 Update 2 (marzo de 2005) y todas las versiones posteriores, incluido
Java 6 (diciembre de 2006), 7 y 8, contienen al menos uno de los CA necesarios en su lista de confianza
predeterminada.
Cuando obtenga acceso a los puntos de enlace de la consola de administración de AWS Lambda o de la
API de AWS Lambda, ya sea a través de un navegador o mediante programación, deberá asegurarse de
que las máquinas cliente admiten alguna de las siguientes entidades de certificación:
• Amazon Root CA 1
• Starfield Services Root Certificate Authority - G2
• Starfield Class 2 Certification Authority
Los certificados raíz de las primeras dos entidades están disponibles en Amazon Trust Services, aunque
mantener el equipo actualizado es la solución más sencilla. Para obtener más información sobre los
certificados proporcionados por ACM, consulte Preguntas frecuentes sobre AWS Certificate Manager.
719
AWS glossary
For the latest AWS terminology, see the AWS glossary in the AWS General Reference.
720

Lambda DG

Cargado por

Copyright:

Formatos disponibles

Lambda DG

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Lambda DG

Cargado por

Copyright:

Formatos disponibles

AWS Lambda

Guía para desarrolladores

AWS Lambda: Guía para desarrolladores

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

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

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

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

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

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

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

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

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

¿Qué es AWS Lambda?

¿Cuándo debo usar AWS Lambda?

¿Es la primera vez que usa AWS Lambda?

Introducción a AWS Lambda

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

Para crear una función de Lambda

1. Abra la consola de AWS Lambda.

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

Uso del diseñador

Invocar la función de Lambda

Para invocar una función

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

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

Para eliminar una función de Lambda

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

Para eliminar el grupo de registros

Para eliminar el rol de ejecución

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

Creación de funciones mediante el editor de la

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

Uso de archivos y carpetas

Para crear un nuevo archivo, proceda del modo siguiente:

Trabajar con código

Trabajar con los botones de la pestaña

• Elija la pestaña del archivo.

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

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

Trabajar con la barra de estado

Trabajar en modo de pantalla completa

Trabajar con preferencias

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

Uso de AWS Lambda con AWS Command Line

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

~/lambda-project$ this is a command

Creación del rol de ejecución

$ aws iam create-role --role-name lambda-ex --assume-role-policy-document file://trust-

El archivo trust-policy.json es un archivo JSON en el directorio actual que define la política de

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

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

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

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

Para crear la función

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

$ zip function.zip index.js

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

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

Puede utilizar la utilidad base64 para descodificar los registros.