Optimized Lambda functions
with Rust (Workshop) 🔨

Luciano Mammino (@loige)

loige.link/rust-lambda-ws

2024-12-12

👋 I'm Luciano (🇮🇹🍕🍝🤌)

👨‍💻 Senior Architect @ fourTheorem

nodejsdp.link

📔 Co-Author of Node.js Design Patterns 👉

Let's connect!

linktr.ee/loige

$ ~ whoami

rust-lambda.com

👋 I'm Luciano (🇮🇹🍕🍝🤌)

👨‍💻 Senior Architect @ fourTheorem

nodejsdp.link

📔 Co-Author of Crafting Lambda Functions in Rust 👉

Let's connect!

linktr.ee/loige

$ ~ whoami

rust-lambda.com

Early-access available at

40% discount! 🤑

Always re-imagining

We are a pioneering technology consultancy focused on AWS and serverless

✉️ Reach out to us at hello@fourTheorem.com

😇 We are always looking for talent: fth.link/careers

We can help with:

Cloud Migrations

Training & Cloud enablement

Building high-performance serverless applications

Cutting cloud costs

loige.co

awsbites.com

loige.co

loige.link/rust-lambda-ws

Grab the slides

loige.co

What is RUST?

loige.link/rust-lambda-ws

Grab the slides

loige.co

What is RUST?

loige.link/rust-lambda-ws

Grab the slides

loige.co

OK... Why do I like RUST?

loige.link/rust-lambda-ws

Grab the slides

loige.co

Why do I like Rust? ❤️

Zero-cost abstractions
Strongly typed with a really good type-system
Takes inspiration from Haskell, C++, OCaml, JavaScript, Ruby
Great (built-in) package manager (Cargo)
Great ecosystem of libraries
Pattern matching, no null, Option & Result types

loige.co

BTW, I am not the only one who likes Rust... 😏

allthingsdistributed.com/2024/06/introducing-distill-cli.html

loige.co

😼 Repo

loige.co

loige.link/rl-repo

💬 Shared Chat

tlk.io/rust-lambda

Let's sink our teeth

into some rusty goodness!

loige.co

rustup.rs

loige.co

cargo new hello-rust

loige.co

cargo new hello-rust
cd hello-rust

loige.co

cargo new hello-rust
cd hello-rust
cargo run

Hello, World!

loige.co

cargo new hello-rust
cd hello-rust
cargo run

Hello, World!

loige.co

Handling missing data & errors

loige.co

null... does not exist in Rust! 😵

loige.co

you can use () to represent no data

Unit type (empty tuple)

loige.co

fn some_function() {
	// ... do something
}

loige.co

fn some_function() -> () {
    // ... do something
}

Implicit

loige.co

But if you want to represent data that might be set or not, you should use Option

loige.co

fn main() {
    let items: Vec<u32> = vec![];
    let first_item = items.first();
}

Option<u32>

Some(u32)

Presence of value

None

🥺 Absence of value

loige.co

fn main() {
    let items: Vec<u32> = vec![];
    let first_item = items.first(); // None
}

loige.co

fn main() {
    let items: Vec<u32> = vec![1,2,3];
    let first_item = items.first(); // Some(1)
}

loige.co

fn main() {
    let items: Vec<u32> = vec![1, 2, 3];
    let first_item = items.first();
    match first_item {
        Some(value) => println!("{}", value),
        None => println!("No items"),
    }
}

😀 Happy path

🥺 Sad path

loige.co

fn main() {
    let items: Vec<u32> = vec![1, 2, 3];
    let first_item = items.first();
    println!("{:?}", first_item.unwrap()); // 1
}

If you cannot get the value, panic!

loige.co

fn main() {
    let items: Vec<u32> = vec![];
    let first_item = items.first();
    println!("{:?}", first_item.unwrap());
}

If you cannot get the value, panic!

thread 'main' panicked at examples/option-unwrap.rs:4:33:
called `Option::unwrap()` on a `None` value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

loige.co

fn main() {
    let items: Vec<u32> = vec![];
    let first_item = items.first();
    println!("{:?}", first_item.expect("No first value"));
}

If you cannot get the value, panic!

thread 'main' panicked at examples/option-expect.rs:4:33:
No first value
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

loige.co

fn main() {
    let items: Vec<u32> = vec![];
    let first_item = items.first();
    println!("{:?}", first_item.unwrap_or(&1)); // 1
}

if you cannot get the value, use a default value!

loige.co

use std::env;

fn main() {
    let region = env::var("AWS_REGION");
}

Result<String, VarError>

😀 Happy path

🥺 Sad path

loige.co

use std::env;

fn main() {
    let region = env::var("AWS_REGION");
    
    match region {
        Ok(region) => println!("Selected region: {}", region),
        Err(_) => println!("Error: AWS_REGION not set"),
    }
}

😀 Happy path

🥺 Sad path

loige.co

use std::env;

fn main() {
    let region = env::var("AWS_REGION")
        .expect("AWS_REGION environment variable not set");
}

String

If you cannot get the value, panic!

loige.co

use std::env;

fn main() {
    let region = env::var("AWS_REGION")
        .unwrap_or_else(|_| "eu-west-1".to_string());
}

Rust makes it very hard for you to ignore possible errors or the absence of values.

if you cannot get the value, use a default value!

loige.co

🤑 FREE Resources for learning Rust

loige.co

THE BOOK: rust-book.cs.brown.edu
Rust by examples: doc.rust-lang.org/stable/rust-by-example
Rust Design Patterns: rust-unofficial.github.io/patterns
Exercism Rust track: exercism.org/tracks/rust
Rustlings: github.com/rust-lang/rustlings

my favourite ones!

Why RUST + Lambda?

loige.co

Why Rust + Lambda

Performance + Efficient memory-wise = COST SAVING 🤑
Very fast cold starts! (proof) ⚡️
Multi-thread safety 💪
No null types + Great error primitives = fewer bugs 🐞

loige.co

Where do we start?

loige.co

Let's try to create a new function

loige.co

loige.co

RUST?!

loige.co

RUST?!

loige.co

EASY PEASY... we just need a custom runtime! 🤗

loige.co

🏃‍♂️ Lambda execution model

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

Poll for events

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

Poll for events

event (JSON)

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

Poll for events

event (JSON)

execute

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

Poll for events

event (JSON)

execute

response or
error

loige.co

🏃‍♂️ Lambda execution model

Runtime

Handler (logic)

Poll for events

event (JSON)

execute

response or
error

response (JSON)
or error

loige.co

Load the handler code

Infinite loop

loige.co

AWS made a Custom Rust Runtime for Lambda!

github.com/awslabs/aws-lambda-rust-runtime

loige.co

Let's make it simple!

install cargo-lambda

loige.co

cargo-lambda.info

loige.co

cargo lambda new hello-lambda

loige.co

cargo lambda new hello-lambda

# Choose HTTP integration!

loige.co

use lambda_http::{run, service_fn, tracing, Body, Error, Request, RequestExt, Response};

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();
    run(service_fn(function_handler)).await
}

async fn function_handler(event: Request) -> Result<Response<Body>, Error> {
    let who = event
        .query_string_parameters_ref()
        .and_then(|params| params.first("name"))
        .unwrap_or("world");
    
    let message = format!("Hello {who}, this is an AWS Lambda HTTP request");

    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body(message.into())
        .map_err(Box::new)?;

    Ok(resp)
}

loige.co

These are just abstractions! 🧐

Lambda is still using JSON behind the scenes.

For HTTP you generally use the Lambda-Proxy integration.

use lambda_http::{run, service_fn, tracing, Body, Error, Request, RequestExt, Response};

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing::init_default_subscriber();
    run(service_fn(function_handler)).await
}

async fn function_handler(event: Request) -> Result<Response<Body>, Error> {
    let who = event
        .query_string_parameters_ref()
        .and_then(|params| params.first("name"))
        .unwrap_or("world");
    
    let message = format!("Hello {who}, this is an AWS Lambda HTTP request");

    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body(message.into())
        .map_err(Box::new)?;

    Ok(resp)
}

loige.co

Lambda-Proxy integration
Example Request (HTTP Event) 🧐

{
  "resource": "/my/path",
  "path": "/my/path",
  "httpMethod": "GET",
  "headers": {
    "header1": "value1",
    "header2": "value1,value2"
  },
  "multiValueHeaders": {
    "header1": [
      "value1"
    ],
    "header2": [
      "value1",
      "value2"
    ]
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "multiValueQueryStringParameters": {
    "parameter1": [
      "value1",
      "value2"
    ],
    "parameter2": [
      "value"
    ]
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "id",
    "authorizer": {
      "claims": null,
      "scopes": null
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "extendedRequestId": "request-id",
    "httpMethod": "GET",
    "identity": {
      "accessKey": null,
      "accountId": null,
      "caller": null,
      "cognitoAuthenticationProvider": null,
      "cognitoAuthenticationType": null,
      "cognitoIdentityId": null,
      "cognitoIdentityPoolId": null,
      "principalOrgId": null,
      "sourceIp": "IP",
      "user": null,
      "userAgent": "user-agent",
      "userArn": null,
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "path": "/my/path",
    "protocol": "HTTP/1.1",
    "requestId": "id=",
    "requestTime": "04/Mar/2020:19:15:17 +0000",
    "requestTimeEpoch": 1583349317135,
    "resourceId": null,
    "resourcePath": "/my/path",
    "stage": "$default"
  },
  "pathParameters": null,
  "stageVariables": null,
  "body": "Hello from Lambda!",
  "isBase64Encoded": false
}

Lambda-Proxy integration
Example Response 🧐

{
    "isBase64Encoded": false,
    "statusCode": 200,
    "headers": { 
      "Content-Type": "text/plain"
    },
    "body": "Hello, World"
}

loige.co

Local Testing

loige.co

cargo lambda watch

loige.co

cargo lambda invoke

# 1. example event
# list of supported example events
# https://github.com/awslabs/aws-lambda-rust-runtime/tree/main/lambda-events/src/fixtures

cargo lambda invoke --data-example apigw-request


# 2. custom JSON event file

cargo lambda invoke --data-file event.json


# 3. inline

cargo lambda invoke --data-ascii '{"name": "Loige"}'

loige.co

Building & Deploying

cargo lambda build --release --arm64 && cargo lambda deploy

loige.co

🔥 HOT TIP

cargo lambda deploy --enable-function-url

loige.co

✏️ Exercise #1

loige.co

The SCREAM endpoint!

Write a Lambda that implements an HTTP API that receives a message via query string parameters and responds with that messages capitalized (in the response body).

Bonus: if no message is provided in the request, return a help message in the response body.

GET https://...?message=Hello

HTTP/1.1
Content-Type: text/plain
Content-Length: 5

HELLO

Different types of
events and responses

loige.co

async fn function_handler(event: LambdaEvent<EventType>) 
  -> Result<ResponseType, Error> {
    
    let (event, context) = event.into_parts();
    
    // ...
}

Request

Response

loige.co

Canonical Handler signature

async fn function_handler(event: LambdaEvent<EventType>) 
  -> Result<ResponseType, Error> {
    
    let (event, context) = event.into_parts();
    
    // ...
}

Generic Event Wrapper

Specific Response Type (Success)

loige.co

Canonical Handler signature

Specific Event Type

async fn function_handler(event: LambdaEvent<EventType>) 
  -> Result<ResponseType, Error> {
    
    let (event, context) = event.into_parts();
    
    // ...
}

Execution context

loige.co

Canonical Handler signature

Specific Event

(extracted)

use aws_lambda_events::event::s3::S3Event;

async fn function_handler(event: LambdaEvent<S3Event>)
  -> Result<(), Error> {
    let (event, context) = event.into_parts();
    println!("{}", context.request_id);
    
    for record in event.records {
        tracing::info!(
            "[{}] Bucket={} Key={}",
            record.event_name.unwrap_or_default(),
            record.s3.bucket.name.unwrap_or_default(),
            record.s3.object.key.unwrap_or_default()
        );
    }
    Ok(())
}

loige.co

Specific Example (S3 event)

async fn function_handler(event: LambdaEvent<S3Event>) 
  -> Result<(), Error> {
    // ...
    Ok(())
}

Request

Response

What if we want to use different types? 🤨

loige.co

Option 1

use type definitions in the aws_lambda_events crate

loige.co

Processing jobs from SQS

Example

Jobs

Event source mapper

loige.co

# Cargo.toml

[dependencies]
aws_lambda_events = { 
  version = "0.15.0",
  default-features = false,
  features = [
    "sqs",
  ]
}

loige.co

use aws_lambda_events::event::sqs::{BatchItemFailure, SqsBatchResponse, SqsEvent};
// ...

async fn function_handler(event: LambdaEvent<SqsEvent>)
  -> Result<SqsBatchResponse, Error> {
    let mut failed_jobs = Vec::with_capacity(event.payload.records.len());

    for record in event.payload.records {
        // process the job
        // ...
        // if the job failed, add it to the failed_jobs list
        failed_jobs.push(BatchItemFailure {
            item_identifier: record.message_id.unwrap_or_default(),
        });
    }

    Ok(SqsBatchResponse {
        batch_item_failures: failed_jobs,
    })
}

// ...

loige.co

Option 2

Create custom request and response types

loige.co

Custom logic in Step Function

Example

loige.link/fsb-refactor

loige.co

# Cargo.toml

[dependencies]
serde = "1"
serde_json = "1"

loige.co

// ...

#[derive(serde::Deserialize)]
struct Request {
    url: String,
}

#[derive(serde::Serialize)]
struct Response {
    issue_number: u32,
}

async fn function_handler(event: LambdaEvent<Request>) 
  -> Result<Response, Error> {
    println!("I am going to scrape {}", event.payload.url);
    // TODO: actual scraping logic here
    Ok(Response { issue_number: 333 })
}

// ...

loige.co

Option 3

Use arbitrary JSON values!

loige.co

// ...

async fn function_handler(
    event: LambdaEvent<serde_json::Value>,
) -> Result<serde_json::Value, Error> {
    let url = event
        .payload
        .as_object()
        .unwrap()
        .get("url")
        .unwrap()
        .as_str()
        .unwrap(); // 🤮
    println!("I am going to scrape {}", url);
    // TODO: actual scraping logic here
    Ok(serde_json::json!({ "issue_number": 333 }))
}

// ...

loige.co

✏️ Exercise #2

loige.co

S3 processing

Write a Lambda that processes S3 events. For every object in the event, print the bucket name, the type of operation, and the object name.

S3 Event

MyBucket - ObjectCreated:Put "Happy Face.jpg"

LOGS

MyBucket - ObjectCreated:Put "lolz.gif"

MyBucket - ObjectCreated:Put "secrets/passwords.txt"

loige.co

Problems with the current deployment approach...

loige

NO TRIGGER CONFIGURED! 🙄

WUT!? 😱

loige.co

... more problems

Configuring our Lambda Function (Memory, timeout, environment variables, permissions, etc.)
Creating various resources for our app (S3 buckets, SQS queues, etc.)
Wiring different resources together (e.g. pass a DynamoDB table name to a Lambda function)
A few resources are created (Log Groups, Roles, Lambdas) that you will need to clean up manually if you need to delete the application.

SAM

Serverless Application Model

IaC with...

loige.co

What is SAM?

A tool that allows you to do IaC (Infrastructure as Code)
You can define all your infrastructure in a declarative configuration file (YAML or JSON)
SAM will read that file and deploy everything consistently
SAM is based on CloudFormation but it offers a more concise syntax for common serverless use cases

loige.co

SAM speed run 🏃

File structure (header, parameters, resources, outputs)
References
Functions

loige.co

File structure

loige.co

# template.yaml
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Runtime: nodejs22.x
    Timeout: 180

Description: "This is a cool serverless project"

Parameters:
  ParameterLogicalID:
    Description: Information about the parameter
    Type: String
    Default: somevalue
    AllowedValues:
      - value1
      - value2

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      Environment:
        Variables:
          MESSAGE: "Hello From SAM"

Outputs:
  OutputLogicalID:
    Description: Information about the value
    Value: Value to return
    Export:
      Name: Name of resource to export

Define a Lambda function

loige.co

Transform: AWS::Serverless-2016-10-31

Resources:
  ExampleHttpLambda:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
    Properties:
      CodeUri: .
      Handler: bootstrap
      Runtime: provided.al2023
      Architectures:
        - arm64
      Environment:
        Variables:
          SOME_VARIABLE: SomeValue
      Events:
        HttpPost:
          Type: Api
          Properties:
            Path: /
            Method: get

Define an S3 Bucket

loige.co

Transform: AWS::Serverless-2016-10-31

Resources:
  MyLovelyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: MyUniqueNameForMyBucket
      PublicAccessBlockConfiguration:
        BlockPublicAcls: true
        BlockPublicPolicy: true
        IgnorePublicAcls: true
        RestrictPublicBuckets: true
      BucketEncryption:
        ServerSideEncryptionConfiguration:
          - ServerSideEncryptionByDefault:
              SSEAlgorithm: aws:kms

Define a DynamoDB Table

loige.co

Transform: AWS::Serverless-2016-10-31

Resources:    
  HealthChecksTable:
    Type: AWS::DynamoDB::Table
    Properties:
      BillingMode: PAY_PER_REQUEST
      KeySchema:
        - AttributeName: "Id"
          KeyType: "HASH"
        - AttributeName: "Timestamp"
          KeyType: "RANGE"
      AttributeDefinitions:
        - AttributeName: "Id"
          AttributeType: "S"
        - AttributeName: "Timestamp"
          AttributeType: "S"

References

!Ref and !GetAtt

loige.co

Transform: AWS::Serverless-2016-10-31

Parameters:
  SomeParameter:
    Description: Information about the parameter
    Type: String

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      Environment:
        Variables:
          MESSAGE: !Ref SomeParameter
          BUCKET_ARN: !GetAtt MyBucket.Arn
          
   MyBucket:
     Type: AWS::S3::Bucket

Util functions

!Sub and !Join

loige.co

Transform: AWS::Serverless-2016-10-31

Parameters:
  AppId:
    Type: String
    Description: A unique name for the deployment

Resources:
  TinykitBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub tinykit-${AppId}
      
  AnotherBucket:
  	Type: AWS:S3:Bucket
    Properties:
      BucketName: !Join ["-", ["my", !Ref AppId, "bucket"]]
                  # my-${AppId}-bucket

Lambda Permissions

loige.co

Transform: AWS::Serverless-2016-10-31

Resources:
  CampaignsTable:
    Type: AWS::DynamoDB::Table
    Properties:
      # ...

  FormRenderingFunction:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
    Properties:
      # ...
      Policies:
        - DynamoDBReadPolicy:
            TableName: !Ref CampaignsTable

🔥 HOT TIP AWS extension for VSCode

loige.co

AWS SAM + Cargo Lambda

SAM Works with Cargo Lambda (beta feature):

Define IaC with the full power of SAM
Build and run your Rust lambdas with Cargo Lambda
Can simulate API Gateway locally!

Note: Cargo Lambda also works with CDK
(github.com/cargo-lambda/cargo-lambda-cdk)

loige.co

# template.yaml

AWSTemplateFormatVersion: "2010-09-09"
Transform:
  - AWS::Serverless-2016-10-31

Resources:
  ExampleHttpLambda:
    Type: AWS::Serverless::Function
    Metadata:
      BuildMethod: rust-cargolambda
    Properties:
      CodeUri: .
      Handler: bootstrap
      Runtime: provided.al2023
      Architectures:
        - arm64
      Events:
        HttpPost:
          Type: Api
          Properties:
            Path: /
            Method: get

# samconfig.toml

version = 0.1

[default]
[default.global]
[default.global.parameters]
stack_name = "rust-http-lambda"

[default.build.parameters]
beta_features = true
[default.sync.parameters]
beta_features = true

Tells SAM to build using Cargo Lambda

Selects a "custom runtime"

Enables SAM beta features

loige.co

Building, Local testing & Deploying

sam build
sam local start-api
sam deploy

loige.co

🔥 HOT (annoying) TIP

sam validate --lint && sam build --beta-features && sam deploy

loige.co

You always need to build before deploying
(if you changed something)

loige.co

Passing configuration to the handler

loige.co

You should load the configuration and initialize clients in the init phase
Then, you can pass those to the handler
This way you are doing the heavy work only once (per lambda instance)
To support this pattern, we need to make our handler "configurable" (i.e. it should receive a config value at every invocation)

🔥 Performance HOT TIP

"init once, reuse many"

loige.co

struct HandlerConfig {
    table_arn: String
}

async fn function_handler(
    config: &HandlerConfig, // <- now we can receive a reference to the config
    _event: LambdaEvent<EventBridgeEvent<Value>>,
) -> Result<(), Error> {
  // ...
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    let table_arn = env::var("TABLE_ARN")
          .expect("TABLE_ARN environment variable is not set");
    
    let config = &HandlerConfig {
        table_arn,
    };

    run(service_fn(move |event| async move {
        function_handler(config, event).await
    }))
    .await
}

✏️ Exercise #3

loige.co

S3 processing with SAM

Let's update our previous exercise (process files from S3) and let's use SAM.

Use a SAM template to define the S3 bucket and the Lambda function. Pass the bucket name to the lambda function using an environment variable.

Note: Be careful with circular dependencies in your template 🥵

Using the AWS SDK for Rust!

loige.co

aws.amazon.com/sdk-for-rust

loige.co

cargo add aws-config aws-sdk-dynamodb

List of available libraries

awslabs.github.io/aws-sdk-rust

You will always need the aws-config crate (credentials and config management)

You will need to install the specific client library for the services you want to us

loige.co

let table_name = env::var("TABLE_NAME").expect("TABLE_NAME not set");

let config = aws_config::defaults(BehaviorVersion::latest())
  .load()
  .await;
let dynamodb_client = aws_sdk_dynamodb::Client::new(&config);

let timestamp = event
  .payload
  .time
  .unwrap()
  .format("%+")
  .to_string();

let mut item = HashMap::new();
item.insert(
	"Id".to_string(),
	AttributeValue::S(format!("https://loige.co#{}", timestamp)),
);
item.insert("Timestamp".to_string(), AttributeValue::S(timestamp));

let insert_result = dynamodb_client
  .put_item()
  .table_name(table_name.as_str())
  .set_item(Some(item))
  .send()
  .await?;

tracing::info!("Insert result: {:?}", insert_result);

✏️ Exercise #4

loige.co

S3 image resizing

Let's update our previous exercise (process files from S3) and let's resize image files.

You have to:

Check if the file is an image (you can match on the extension)
Read the content of the file using the S3 SDK
Load the image in memory and resize it (image crate)
Save the resulting image to S3 using the S3 SDK (examples)

Note: remember to give your Lambda permissions to read and write to the S3 bucket!

Note: Try to create the S3 client on the init phase and pass it as configuration!

✏️ Exercise #4

loige.co

S3 image resizing

🔥 SUPER IMPORTANT: Be careful with circular invocation loops!

If you save the generated image in the same bucket, you might trigger the lambda again!

🌠

✏️ Exercise #4

loige.co

S3 image resizing

🔥 SUPER IMPORTANT: Be careful with circular invocation loops!

Possible solutions:

Use different buckets (source images, generated images)
Use different object prefixes and trigger the Lambda only on specific prefixes (e.g. /uploads/ vs /thumbnails/)

✏️ Final project

Website Health-check App

loige.co

Trigger a Lambda
on a schedule

loige.co

Transform: AWS::Serverless-2016-10-31

Resources:
  HealthCheckLambda:
    Type: AWS::Serverless::Function
    Properties:
      # ...
      Events:
        ScheduledExecution:
          Type: Schedule
          Properties:
            Schedule: rate(30 minutes)
            Enabled: false

# Cargo.toml

[dependencies]
reqwest = { 
  version = "0.12.4", 
  default-features = false, 
  features = [
    "json",
    "rustls-tls",
    "http2",
  ]
}

loige.co

Making HTTP Requests

let client = reqwest::Client::builder()
  .timeout(Duration::from_secs(10))
  .build()?;
  
let resp = client
  .get("https://loige.co")
  .send()
  .await
  .expect("Failed to send request");
  
dbg!(resp.status().is_success());
dbg!(resp.status().as_u16());

let content = resp
  .text()
  .await
  .expect("Failed to read response body");

loige.co

Making HTTP Requests

Step By Step Solution

github.com/lmammino/rust-lambda-workshop

loige.co

Closing notes

Lambda is great (but you knew that already 😉)
Writing Lambdas in Rust is fun and it can be very cost-efficient
Still not very common to write Lambdas in Rust, but the tooling and the DX is already quite good (Cargo Lambda + SAM / CDK)
Go, have fun, share your learnings!

loige.co

BONUS: SAM + Cargo Lambda
a complete example

github.com/lmammino/earthquake-notifier

loige.co

BONUS 2: another complete example

github.com/lmammino/oidc-authorizer

Benchmark vs 🐍

🚀 16x faster cold starts

⚡️ 3.5x less memory

🤑 3x cheaper

Link

loige.co

Thanks to @gbinside, @conzy_m, @eoins, and @micktwomey for kindly reviewing this talk!

THANKS!

Grab these slides!

rust-lambda.com

loige.link/rust-lambda-ws

loige.co

Optimized Lambda functions with Rust (Workshop)

By Luciano Mammino

Optimized Lambda functions with Rust (Workshop)

Abstract You're already familiar with AWS Lambda and its potential for scalability and cost savings. Now, imagine harnessing the performance and efficiency of the Rust programming language to take your serverless functions to the next level. This workshop is designed for developers who are comfortable with AWS and Lambda, but want to explore the benefits of using Rust as their serverless runtime. With a focus on practical implementation, we'll cover everything you need to know to write efficient, scalable, and maintainable AWS Lambda functions in Rust. What You'll Learn Why the combination of Rust and AWS Lambda is a perfect match for optimized performance The tooling ecosystem, including the Rust runtime for Lambda and cargo lambda CLI utility How to bootstrap, test locally, compile, deploy, and remotely test your first Lambda function in Rust Best practices for handling different event types (HTTP, SQS, EventBridge, custom) and responses Integration with Infrastructure as Code tools like AWS SAM Dependency management, code organization, and testing strategies for Rust serverless applications Takeaways By the end of this workshop, you'll have a solid understanding of how to leverage Rust's performance benefits in your AWS Lambda functions. Whether you're looking to reduce costs, improve response times, or simplify development workflows, this session will provide you with the

Luciano Mammino PRO

Cloud developer, entrepreneur, fighter, butterfly maker! #nodejs #javascript - Author of https://www.nodejsdesignpatterns.com , Founder of https://fullstackbulletin.com

Optimized Lambda functions with Rust (Workshop) 🔨

$ ~ whoami

$ ~ whoami

Always re-imagining

We are a pioneering technology consultancy focused on AWS and serverless

What is RUST?

What is RUST?

OK... Why do I like RUST?

Why do I like Rust? ❤️

BTW, I am not the only one who likes Rust... 😏

😼 Repo

💬 Shared Chat

Let's sink our teeth

into some rusty goodness!

🤑 FREE Resources for learning Rust

Why RUST + Lambda?

Why Rust + Lambda

Where do we start?

Let's try to create a new function

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

🏃‍♂️ Lambda execution model

AWS made a Custom Rust Runtime for Lambda!

Let's make it simple!

install cargo-lambda

Building & Deploying

🔥 HOT TIP

✏️ Exercise #1

The SCREAM endpoint!

Different types of events and responses

Canonical Handler signature

Canonical Handler signature

Canonical Handler signature

Specific Example (S3 event)

Option 1

Processing jobs from SQS

Example

Option 2

Custom logic in Step Function

Example

Option 3

✏️ Exercise #2

S3 processing

Problems with the current deployment approach...

... more problems

SAM

Serverless Application Model

IaC with...

What is SAM?

SAM speed run 🏃

File structure

Define a Lambda function

Define an S3 Bucket

Define a DynamoDB Table

References

Util functions

Lambda Permissions

🔥 HOT TIP AWS extension for VSCode

AWS SAM + Cargo Lambda

Building, Local testing & Deploying

🔥 HOT (annoying) TIP

You always need to build before deploying (if you changed something)

Passing configuration to the handler

🔥 Performance HOT TIP

"init once, reuse many"

✏️ Exercise #3

S3 processing with SAM

Using the AWS SDK for Rust!

✏️ Exercise #4

S3 image resizing

✏️ Exercise #4

S3 image resizing

✏️ Exercise #4

S3 image resizing

✏️ Final project

Website Health-check App

Optimized Lambda functions
with Rust (Workshop) 🔨

Different types of
events and responses

You always need to build before deploying
(if you changed something)

Trigger a Lambda
on a schedule

BONUS: SAM + Cargo Lambda
a complete example