Serverless on {O}

Building a Practical Serverless API with SAM: Leveraging Nested Stacks for Organization

Mon, 01 Jan 0001 00:00:00 +0000

This example demonstrates how to build and deploy a simple serverless API using AWS Lambda, API Gateway, and AWS SAM (Serverless Application Model). The core focus here is on leveraging modularity and nested stacks to create a well-organized and scalable project structure.

Project Structure

Here’s a quick overview of the project’s key components:

api.yaml: This SAM file defines the API Gateway. It’s responsible for linking HTTP paths (like /orders and /logs) to the appropriate Lambda Functions. Crucially, it imports the API definition from openapi.yaml.
log.yaml: This SAM file contains the definition for the Lambda Function responsible for fetching logs (GetLogs).
order.yaml: This SAM file contains the definition for the Lambda Function responsible for fetching orders (GetOrders).
openapi.yaml: This is the OpenAPI (Swagger) file that specifies the API paths (e.g., /orders, /logs) and how they integrate with the Lambda Functions. Here, we define the x-amazon-apigateway-integration that links each path to the ARN of the relevant Lambda Function.
template.yaml: This is the main SAM template for your project. It acts as an orchestrator for all the sub-stacks (OrderStack, LogStack, ApiStack). Each sub-stack points to its respective YAML file using the Location property of AWS::Serverless::Application.

Why Modularity and Nested Stacks?

Modularity & Organization: When you split your project into separate files like order.yaml, log.yaml, and api.yaml, your project becomes easier to organize and understand. Each file focuses on one part of the app, so it’s easier to work on and update, especially when the project gets bigger.

Serverless Image Processing with AWS SAM: Uploads, Thumbnails & S3 Events

Mon, 01 Jan 0001 00:00:00 +0000

This example demonstrates a robust serverless architecture on AWS for handling file uploads and automated thumbnail generation. It leverages AWS SAM (Serverless Application Model), Lambda functions, API Gateway, and S3 event notifications to create a streamlined and scalable image processing pipeline.

Project Structure

Here’s a quick overview of the project’s key components:

functions/: Contains the core Lambda function code:
- event.mjs: Handles S3 event notifications, triggering the thumbnail generation process.
- upload.mjs: Manages the initial file upload through API Gateway.
layers/nodejs/: A Lambda layer containing shared code and dependencies for the functions:
- lib/utils.mjs: Common utility functions.
- package.json & package-lock.json: Node.js dependencies for the layer.
template.yaml: The AWS SAM template defining the serverless resources: Lambda functions, API Gateway endpoints, S3 buckets, and their respective permissions and event triggers.

How It Works

The workflow is straightforward and efficient:

Serverless Messaging with AWS SAM: SNS, SQS, and Lambda

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to build a serverless messaging pipeline using AWS SAM. The project uses SNS to publish messages, SQS queues to separate concerns, and Lambda functions to process the data. It also uses filter policies to control message delivery to each queue.

This architecture is useful when you want to send different types of data to different consumers, and keep your application components decoupled.

Project Structure

The template defines:

Customizing Cognito Emails with AWS SAM and Lambda

Mon, 01 Jan 0001 00:00:00 +0000

This example shows how to use AWS SAM to create a user sign-up system (Cognito) and change the automatic emails it sends, like account verification or password reset emails. This is a great method if you want your application’s messages to match your brand’s style.

Project Components

The project has two main files:

cognito-email/index.js: This file contains a simple Lambda function. Its job is to change the content of the emails.
template.yaml: This file tells AWS what to build. It includes:
- Cognito User Pool: The place where user data is saved.
- Lambda Function: A simple function that runs when needed.
- Permissions: These allow Cognito to call the Lambda function.

How It Works

This setup customizes the email messages that Cognito sends in different user flows, such as:

Serverless API Monitoring with AWS SAM: Lambda, API Gateway & CloudWatch Alarms

Mon, 01 Jan 0001 00:00:00 +0000

This example demonstrates how to build a lightweight, serverless API using AWS SAM (Serverless Application Model) while integrating real-time error monitoring and email alerts using CloudWatch Alarms and SNS. This pattern is ideal for production-ready serverless applications that need observability without heavy tooling.

Project Structure

The project includes the following core components:

functions/: Contains the Lambda function that handles HTTP requests:
- app.mjs: Returns a simple response (e.g., “Hello World”).
template.yaml: The SAM template defining resources including:
- Lambda Function (hello handler)
- API Gateway (to expose the function via HTTP)
- CloudWatch Alarm (monitors API 5XX errors)
- SNS Topic & Subscription (sends email alerts)

How It Works

This architecture sets up an API and monitors its availability in real time:

Organizing Serverless Code with AWS SAM: Lambda Layers and Testing with Jest

Mon, 01 Jan 0001 00:00:00 +0000

This example demonstrates how to build clean, testable, and modular serverless applications on AWS using AWS SAM, Lambda Layers, and Jest. It focuses on two essential practices for scalable serverless development:

Using Lambda Layers to share code across functions
Using Jest to properly test each function and its dependencies

By combining these two patterns, you get a powerful structure that’s maintainable, reusable, and confidently testable.

Project Overview: Shared Logic + Layer for Node Modules + Testing

functions/ – Your Lambda function handlers: