Serverless service / Function as a service allowing to run code without having to worry about underlying hardware and OS.
Event driven: the lambda is triggered by an event.
Pay only for what you use: per request and based on the duration of the code execution.
Use cases
Data transformation (Kinesis Data Stream as input)
File processing (when uploaded to S3 bucket)
Website backend microservice
Scheduled tasks
Bad use cases
Long running processes (timeout after 15mn)
Constant workload (no scalability and high cost)
Large code base (needed to be loaded at startup)
State management (lambda are stateless)
Anti-patterns
Monolithic function
increase package size
hard to enforce least privilege permissions
hard to upgrade, maintain and test
Recursion
endless loop
Orchestration
avoid complex workflow logic
ties lambda with other systems
instead consider AWS Step Functions or EventBridge
Chaining (synchronously invoke another lambda)
instead use EventBridge or QueueService
Waiting (synchronously call services or databases)
instead use asynchronous calls
Runtime
OS
Libraries
Programming language (.NET, Node.js, Python, Go, Ruby, Java)
Environnement variables
DOTNET_STARTUP_HOOKS
ex: path to an assembly to inject logging
Wrapper scripts
Execute the wrapper on top of the runtime and the lambda function.
run shell commands and binaries
Use AWS_LAMBDA_EXEC_WRAPPER to point to your wrapper script.
result sent to the configured destination otherwise lost
Configuration
Setting
Description
Memory
from 128 MB (default) to 10 GB
vCPU
1'769 MB = 1 vCPU, 10 GB = 6 vCPU, for single-threaded code allocated more than 1'769 MB is useless. Compare ARM and x86.
timeout
from 1s to 15mn, default to 3s
VPC
by default no VPC access configured → Amazon VPC → internet access
if VPC access is configured → access to VPC resources → no internet connection
use an Hyperplane ENI to add internet connection in addition of a VPC access
Ephemeral storage
/tmp from 512 MB (default) to 10 GB
Execution role
define what the function is allowed to do
Resource-based policy
define what others are allowed to do to the function
Environment variables
Key-value pair of strings
Stored in the configuration for a Lambda function version
Accessible within the Lambda code function
Storage
Directories
Path
Description
/var/task
Lambda package (function files)
/tmp
Temporary storage with write access
/opt
Lambda layer (layer files)
Elastic File System (EFS)
Persistent
Serverless, scalable
Support concurrent access
Require VPC access
S3
Persistent
No VPC required
Accessed via API
IAM entities
Type
Description
User
individual with unique credentials
Role
entity for temporary access (access to a db)
Policy
permission for access to resources (apply to a user or a role to read from a specific db table)
User group
logical collection of users for easier management
Synchronous execution
Invocation result
Result content
Description
Status code
200 success, 4xx or 5xx error
Executed version
Log result
last 4 KB of the execution log in base64 encoding
Function error
only if an error occured. Code error, timeout, invalid JSON output
Response body
payload
Asynchronous execution
The Lambda is executed and its result (Invocation Record) is sent to a destination.
Destinations:
Simple Notification Service (SNS) topic
Simple Queue Service (SQS) queue
Lambda function
EventBridge event bus
Event Source
Simple Queue Service (SQS) queue
DynamoDB stream
Lambda has builtin functionalities to poll the event source with batching and filtering functionality.
Event source mapping polls and gathers records before it will initialize a Lambda function and send a batch of events to it for processing.
# install the VS project template
dotnet new install Amazon.Lambda.Templates
# install the command line tools
dotnet tool install -g Amazon.Lambda.Tools
Install the AWS Toolkit for Visual Studio extension.
AWS Lambda application types
AWS Lambda application type
Description
Class library
Executable assembly
AWS Serverless Application
ASP.NET application hosted in the AWS environment. It has a handful of additional dependencies that make it interoperate with AWS runtime.
C# class library
You provide Lambda with information about your function's handler in the form of a handler string: ASSEMBLY::TYPE::METHOD
ASSEMBLY is the name of the .NET assembly file for your application. If you use the Amazon.Lambda.Tools CLI to build your application and you don't set the assembly name using the AssemblyName property in the .csproj file, then ASSEMBLY is simply the name of your .csproj file.
TYPE is the full name of the handler type, which consists of the Namespace and the ClassName.
METHOD is the name of the function handler method in your code.
// Assembly attribute to enable the Lambda function's JSON input to be converted into a .NET class.
[assembly: LambdaSerializer(typeof(Amazon.Lambda.Serialization.SystemTextJson.DefaultLambdaJsonSerializer))]
namespaceMyProject;
publicclassFunction
{
publicstringFunctionHandler(stringinput, ILambdaContextcontext)
{
return input.ToUpper();
}
}
On VS, if the extension AWS Toolkit is installed, you have the AWS .NET Mock Lambda Test Tool available which allows you to debug locally.
Properties/launchSettings.json
{"profiles":{"Mock Lambda Test Tool":{"commandName":"Executable","commandLineArgs":"--port 5050","workingDirectory":".\\bin\\$(Configuration)\\net8.0","executablePath":"%USERPROFILE%\\.dotnet\\tools\\dotnet-lambda-test-tool-8.0.exe"}}}
Using the C# 9's top-level statements feature, you generate an executable assembly which will be run by the Lambda. You provide Lambda only with the name of the executable assembly to run.
varhandler = async (string argument1, ILambdaContext context) => { };
// bootstrap the Lambda runtime and pass it the handler methodawait LambdaBootstrapBuilder.Create(handler, newDefaultLambdaJsonSerializer()).Build().RunAsync();
To debug locally you have to create the debug configuration file for you lambda.
Properties\launchSettings.json
{"profiles":{"Mock Lambda Test Tool":{"commandName":"Executable","commandLineArgs":"--port 5050","executablePath":"%USERPROFILE%\\.dotnet\\tools\\dotnet-lambda-test-tool-8.0.exe","workingDirectory":".\\bin\\$(Configuration)\\net8.0","environmentVariables":{"AWS_LAMBDA_RUNTIME_API":"localhost:5050","AWS_PROFILE":"MyProfile","AWS_REGION":"us-east-1"}}}}
The Lambda on AWS has wrongly set the handler to LambdaTest.
AWS - Lambda - Functions - select your function - Code tab - Runtime settings - Edit - change the Handler
Your function doesn't have permission to write to Amazon CloudWatch Logs
AWS → IAM → Roles → [the roles used by your lambda] → Persissions policies → Add permission → Create inline policy