Curriculum Overview: AWS Serverless Compute (Lambda & Fargate)

This curriculum is designed to guide learners through the transition from traditional server-based infrastructure to the AWS serverless paradigm, specifically focusing on AWS Lambda and AWS Fargate.

[!IMPORTANT] Serverless does not mean there are no servers; it means the cloud provider (AWS) manages the underlying infrastructure, scaling, and maintenance, allowing developers to focus solely on code.

## Prerequisites

Before starting this curriculum, students should have a baseline understanding of the following:

• Cloud Fundamentals: Familiarity with the AWS Global Infrastructure (Regions, Availability Zones).
• Basic Compute Concepts: Understanding of Virtual Machines (Amazon EC2) and the concept of "Always-on" vs. "On-demand."
• Development Literacy: Basic knowledge of code execution environments (Python, Node.js, etc.) and Containerization (Docker) is helpful but not mandatory.
• IAM Basics: Understanding how permissions are granted in a cloud environment.

## Module Breakdown

## Learning Objectives per Module

Module 1: The Serverless Revolution

• Define the Serverless model and the shift in the Shared Responsibility Model.
• Explain Subsecond Billing and how it differs from hourly EC2 pricing.
• Identify the benefits of Elasticity without manual configuration.

Module 2: AWS Lambda

• Recognize AWS Lambda as a Function-as-a-Service (FaaS).
• Understand the 15-minute timeout limitation for individual functions.
• Identify event sources (triggers) such as Amazon S3, DynamoDB, and API Gateway.

Module 3: AWS Fargate

• Explain Fargate as a serverless engine for Amazon ECS and Amazon EKS.
• Contrast Fargate with managing EC2 instances for container orchestration.
• Identify when a containerized workload is preferable over a standalone function.

Module 4: Decision Matrix

• Compare Lambda, Fargate, and EC2 based on execution time, cost, and management overhead.
• Select the appropriate compute service based on specific business requirements (e.g., long-running vs. event-driven).

## Visual Anchors

AWS Lambda Event-Driven Workflow

Compute Selection Logic

## Success Metrics

To demonstrate mastery of this curriculum, the learner should be able to:

• Distinguish between Lambda and Fargate in a mock exam scenario with 100% accuracy.
• Map at least three different AWS triggers to a Lambda function (e.g., S3 upload -> Lambda -> Rekognition).
• Explain the cost implications: specifically why Lambda is 0 when not running, whereas EC2 involves a base cost.
• Identify the maximum execution time for Lambda (900 seconds/15 minutes).
• Define the relationship between Fargate and ECS/EKS (Fargate is the compute, ECS/EKS is the orchestrator).

## Real-World Application

In a professional setting, mastering these compute options allows for:

1. Cost Optimization: Moving from $24/7$ EC2 instances to Lambda for intermittent tasks can save companies up to 80%-90% on compute costs.
2. DevOps Efficiency: Engineers no longer spend time patching operating systems or scaling clusters manually, leading to faster deployment cycles.
3. Modern Architecture: This knowledge is the foundation of Microservices, where applications are broken into small, independent, and highly scalable components.

## Practical Examples

Example 1: Image Processing (AWS Lambda)

• Scenario: A social media app needs to create a thumbnail every time a user uploads a high-resolution photo.
• Implementation: A photo is uploaded to an Amazon S3 bucket. This event triggers a Lambda function that resizes the image and saves the thumbnail back to S3.
• Why Serverless?: The code only runs for a few seconds per image. You only pay for those seconds, and it scales perfectly if 1 or 1,000 users upload at once.

Example 2: Continuous Web API (AWS Fargate)

• Scenario: A company has a legacy web application packaged as a Docker container that needs to be available $24/7$ and handles complex sessions.
• Implementation: The container is deployed to Amazon ECS using AWS Fargate as the launch type.
• Why Serverless?: Fargate manages the underlying servers, but because the app must stay alive to handle web traffic, it provides the persistent environment needed while removing the burden of server maintenance.

[!TIP] Remember: If the task is Event-Driven and Short, think Lambda. If the task is Containerized and Persistent, think Fargate.