Top 8 Recommended Serverless Framework Self-Study Materials! [November 2024]

AWS Lambda and the Serverless Framework is the QUICKEST way to get started in the serverless world, to deploy AWS Lambda functions in Amazon Web Services that infinitely scale without managing any servers!

This course, unlike others, has an approach that teaches you how to deploy AWS Lambda functions from the first lectures properly.

• no manual work through the AWS UI

• all your configuration and deployment is coded using YAML and the Serverless framework

• no headaches packaging your functions as zip files

AWS Lambda is a fantastic tool to master when learned the right way.

• Save in cost - you only pay per usage

• save in operational burden - no servers to manage!

• Scale automatically from 0 to millions of API calls.

Additionally, you will learn AWS SAM (Serverless Application Model), another framework used to configure, develop and deploy serverless applications.

For this course, we'll deploy several real-world functions to AWS Lambda:

• An automated thumbnail generation service on S3 (Python)

• A REST API using AWS API Gateway & Lambda (nodeJS)

• A REST API using AWS API Gateway & Lambda (Python 3)

• An Email Service Using Lambda, SES, API Gateway, and NextJS for the front-end (NodeJS)

• An Email Subscriber Service using SNS, API Gateway, S3, EventBridge (Schedule), DynamoDB, Lambda, SendGrid API (NodeJS)

After finishing the course, you'll be able to write any function you want.

In this course, you will be learning, by doing, everything you need to know to be proficient at using AWS Lambda and integrating with many different AWS services through the Serverless Framework and AWS SAM framework!

Try this course, and you have 30 days to be refunded if you don't like it. You have nothing to lose!

---------------------------------

This course also comes with:

• Lifetime access to all future updates

• A responsive instructor in the Q&A Section

• Udemy Certificate of Completion Ready for Download

• A 30 Day "No Questions Asked" Money Back Guarantee!

Join me in this course if you want to learn about AWS Lambda and the Serverless Framework and master the AWS platform!

1. Course Introduction
2. Instructor Introduction
3. Course Objectives/Who Is this Course For
4. What Will You Learn in This Course
5. AWS Lambda Overview and Scenario
6. Code Download
7. Code Download
8. AWS Lambda & the Serverless Framework - Getting Started
9. AWS Lambda Console - Create Your First Lambda Function
10. Installing Serverless Framework & Setting up an AWS Profile
11. Deploying our First Function with Serverless
12. Updating the Function from the CLI
13. Fetching the Function Logs from the CLI
14. Removing the Function Completely
15. Section Summary
16. AWS Lambda & Serverless - Deep Dive
17. Create AWS Lambda Function Using any Runtime
18. YAML Crash Course
19. AWS Lambda and Serverless Framework Core Concepts
20. Functions Timeout and Memory
21. Inheriting Settings from the Provider Property
22. IAM Permissions for Lambda Functions
23. Environment Variables in AWS Lambda
24. VPC for Lambda Functions
25. AWS Lambda Pricing
26. AWS SAM CLI Setup
27. Setting up VS Code and AWS Toolkit
28. Installing the AWS CLI
29. Setting up AWS Configurations
30. Install Docker
31. Install AWS SAM CLI
32. AWS SAM CLI - Running AWS Lambda Function Locally
33. Introduction to AWS SAM
34. Creating and Running Our First AWS SAM Application
35. Deploy the AWS SAM App to AWS Cloud
36. Hosting the API Locally
37. Invoking your Lambda Function Directly
38. Deleting the Stack
39. Section Summary - What We've Done
40. Creating AWS SAM Apps Using VSCode & AWS Toolkit
41. Creating an AWS SAM Serverless Application in VS Code and AWS Toolkit
42. Deploying to AWS Console
43. Run and Debug Directly from the Project
44. Section Summary
45. AWS Step Functions - An Introduction
46. Step Functions - Introduction
47. Creating our First Step Function
48. Adding a Wait State to our State Machine in Step Function
49. Wait State in Step Function
50. Choice State - Full Example
51. The Task State - Step Functions with Lambda Functions
52. Step Functions & State Machine Using VS Code
53. Creating Step Functions with AWS SAM CLI vs VS Code
54. Creating State Machine from Template with VS Code and AWS Toolkit
55. Updating a State Machine
56. Section Summary
57. [Hands-on] - Real World Example Service - 1 - Thumbnail Creation (Python)
58. Creating Thumbnail Generator Service - Setup Basics - IAM Roles
59. Setup the Thumbnail Generator - Code - Part 1
60. Serverless YAML Setup - Configuring S3 and Custom Variables - Deploying the App
61. Adding a Layer Dependency to our Function - Debug Session
62. Setting up DynamoDB for Saving Thumbnail Metadata
63. Saving Thumbnail URLs and Metadata to Database
64. Creating a REST API (AWS API Gateway) for Thumbnail Metadata
65. Deleting and Updating Items with Postman
66. Clean up
67. Final Thoughts - Section Summary
68. [Hands-on] - Real World Example Service 2 - REST API (Python)
69. REST API with Python - Code Walkthrough
70. Testing and Debugging the API
71. Final Thoughts - Python REST API
72. [Hands-on] - Real World Example Service 3 - REST API (NodeJS)
73. Getting Started with Todo REST API - NodeJS
74. Creating a Todo - API Endpoint - Saving a Todo Through the API End Point
75. Listing All Todos - API End Point
76. Getting a Single Todo
77. Delete a Todo
78. Update a Todo
79. Clean up
80. Next Steps for REST APIs
81. [Hands-on] - Real World Example Service 4 - Contact us Form - SES, API Gateway
82. Amazon SES Introduction
83. Setting up the Email Service and Deploying It
84. Deploying SES Service and Testing
85. Setting up SES the Lambda function and the Front-end & SendEmail
86. SES Final Toughts
87. [Hands-on] - Real World Example Service 5 - Email Subscription Architecture
88. Email Subscription Service - Architecture Walkthrough
89. Setting up Our Service - Adding IAM roles for S3 & Uploading the JSON File to S3
90. Setting up the getQuotes End Point and Deploying the Service
91. Creating a Subscriber API Endpoint
92. Finished with Subscriber API EndPoint - What's Next
93. SES vs SNS
94. Setting up SNS in Serverless YAML and Confirming Email
95. Setting up SNS and the Mailer Endpoint
96. Using SNS to Publish Messages to Subscribers via the new Endpoint
97. Creating the Frontend Form and Sending Messages
98. Setting up SendGrid Email API
99. Setting up the SendEmail Endpoint
100. Set up SendEmail and getSubscriber Endpoints
101. Sending Email to our Subscribers with SendGrid API
102. Scheduling Events with EventBridge and CouldWatchEvent (Schedule)
103. Final Thoughts - Section Summary
104. Next Steps
105. Next Steps
106. Bonus Lecture
107. Next Steps
108. Bonus

The only course you'll ever need to master AWS Lambda and Serverless. Period.

Serverless Computing is one of the top-paying cloud skills today. Serverless is also a key focus area in AWS Certification exams, at Associate as well as at Professional level. And this course will help you master all the different pieces to the serverless puzzle.

WELCOME TO THE MOST COMPREHENSIVE COURSE IN SERVERLESS COMPUTING!

You’ll learn Serverless Computing from scratch. We’ll dive into it from scratch, and then we’ll dive into all its core features and into many advanced features as well. We’ll learn how it works, why we use it and how to use it. No prior knowledge of Serverless Computing is necessary!

What You Will Learn:

• AWS Lambda

• API Gateway

• Amazon DynamoDB

• AWS Step Functions

• AWS SAM (Serverless Application Model)

• The Serverless Framework

• AWS CI/CD Tools (Git, CodeCommit, CodeBuild, CodePipeline)

• Serverless Best Practices

• Serverless Architecture Patterns

i.e. the complete gamut of AWS Serverless Architecture. And while you learn, if you need my help, just ask in the Q&A section. You’ll receive prompt response.

20+ HOURS OF HANDS-ON LABS will teach you to:

• Build Serverless Workflows

• Process Streaming Data

• Setup Serverless Authentication and Authorization

• Build Serverless APIs

• Build Serverless Web App

• Build Android and iOS Mobile Apps

• Create an Alexa skill

• Make an IoT app

• And so much more... step by step, all in this one course.

This Course uses Node.js and JavaScript

For all the demos that require the use of AWS SDKs, we'll use the AWS SDK for JavaScript.

Knowledge of Node.js and JavaScript is good to have for taking this course. This shouldn’t however stop you from taking the course. If you are new to JavaScript or Node.js, I cover the Node.js and JavaScript fundamentals as an optional section inside this course.

The JavaScript and Node.js topics covered in the course will help you get up and running with using the AWS SDK and perform the demos presented in this course. However, keep in mind that, as this course is not a JavaScript or Node.js course.

The course uses Angular and Ionic for web and mobile app demos. Knowledge of Angular or Ionic, however is not required for you to be able to complete the demos presented in the course.

--------

By the end of this course, you’ll have mastered the AWS Serverless Architecture and you’ll become confident to take on real world serverless projects.

Take a look at these student reviews:

"Riyaz does a great job patiently explaining complex topics going through good examples of AWS Serverless design flows. A great up to date course with a ton of material." - Stephen B.

"Very good course, the name "bootcamp" is very apt as it's pretty intense." - Rodrigo V.

"Perfect to enhance my skills after already having being Certified as an AWS Solutions Architect - Associate." - Dan R.

"Awesome course as the efforts put by instructor is priceless. Must watch if you want to become a aws serverless expert and appreciate the efforts of instructor." - Mansi

--------

Remember, you are in good hands! I'm waiting to help you inside the course! This is an online course, so you can take it at your own pace. If you’re busy right now, that's okay. Sign up today, and take the course at your own pace.

I look forward to welcoming you inside the course!

1. Getting Started with Serverless Computing on AWS
2. Course Overview
3. What is Serverless? (A 30,000 ft. View)
4. How Serverless Works?
5. How to Create 'Hello World' API with Serverless
6. Dec 2023 Course Update
7. How to Create Your First Lambda Function
8. How to Integrate AWS Lambda function with API Gateway
9. Lambda Function with Node.js 8.10 Runtime
10. Serverless Architecture – Key Features, Benefits and Challenges
11. Major Players in Serverless Space and Why AWS
12. Overview of Core Serverless Services in AWS
13. Overview of Additional Serverless Services in AWS
14. Use Cases of Serverless Architecture
15. Overview of Frameworks and CI/CD Tools for Serverless
16. Environment Setup (IAM Admin User, Env Vars)
17. Environment Variables Setup on Mac
18. Environment Setup (AWS CLI)
19. Environment Setup (Node, VS Code, Postman)
20. Test the Setup
21. My Recommended Approach to Taking this Course
22. Serverless Foundation - AWS Lambda
23. Quick Overview of AWS Lambda
24. Lambda Console Walkthrough
25. Lambda Console Walkthrough Continued
26. Lambda Permissions Model
27. Lambda Handler Syntax in Node.js 6.10 and Node.js 8.10
28. Event Object, Invocation Types, Event Sources
29. Context Object, its Methods and Properties
30. Logging and Error Handling
31. Hands on Demo: Passing Parameters via the Event Object
32. Hands on Demo: Accessing Path and Query String Parameters from the Event Object
33. Hands on Demo: Deploying the Lambda function with ZIP File
34. Quick Note on using Lambda Node.js 12.x Runtime
35. Hands on Demo: S3 Events Example (Serverless Image Resizing)
36. Hands on Demo: Handling S3 Events in Lambda
37. Configuring S3 Event Trigger for Lambda function
38. Hands on Demo: Deploying Lambda via AWS CLI
39. Testing the S3 Event Trigger for Lambda
40. AWS Lambda Limits
41. AWS Lambda Pricing
42. Serverless Foundation - Amazon API Gateway
43. Quick Overview of Amazon API Gateway
44. Query String and Path Parameters
45. Testing the API Endpoint
46. CORS Configuration for Lambda Proxy Integration
47. Adding Request Validators for Query String and Headers
48. POST Request Example - Creating Lambda Function
49. POST Request Example - Creating the API Endpoint
50. Body Mapping Templates - Request Mapping with Velocity Language
51. Body Mapping Templates - Apache VTL (Velocity Template Language) Syntax
52. Body Mapping Templates - Response Mapping with Velocity Language
53. Testing the API with Postman
54. CORS and OPTIONS Preflight Requests Configuration
55. API Gateway Models and JSON Schemas
56. Using Models for Request Body Validation
57. Using Models for Body Mapping
58. Using Gateway Responses for Error Handling
59. API Gateway Post Deploy Options, Logging and Monitoring
60. Client SDK Generation
61. Exporting Swagger Files
62. Creating API Documentation
63. Creating API Keys and Usage Plans in API Gateway
64. Passing API Keys with API Gateway Requests
65. API Gateway Pricing
66. Serverless Foundation - Amazon DynamoDB
67. Amazon DynamoDB - Section Overview
68. What is DynamoDB
69. Terminology Comparison with SQL
70. Data Types in DynamoDB
71. DynamoDB Consistency Model
72. Overview of DynamoDB Capacity Units
73. Calculating Read and Write Capacity Units
74. Basics of DynamoDB Partitions
75. Basics of DynamoDB Indexes
76. Local Secondary Indexes
77. Global Secondary Indexes
78. Overview of Your First DynamoDB Table
79. Hands on Demo: Creating the DynamoDB Table
80. Hands on Demo: Performing Write Operations with AWS Console
81. Hands on Demo: Performing Read Operations with AWS Console
82. Additional Features in DynamoDB Console
83. Hands on Demo: Working with DynamoDB with AWS SDK – Getting Ready
84. Hands on Demo: Listing and Describing Tables using AWS SDK
85. Hands on Demo: Creating, Updating and Deleting Tables using AWS SDK
86. Overview of Item Level Operations with AWS SDK
87. Hands on Demo: Performing Write Operations using AWS SDK
88. Hands on Demo: Conditional Writes in DynamoDB
89. Hands on Demo: Performing Read Operations using AWS SDK
90. Hands on Demo: Paginated Reads in DynamoDB
91. Hands on Demo: Performing Paginated Reads with AWS SDK
92. Serverless Deep Dive - AWS Lambda, API Gateway and DynamoDB
93. Lambda Versions
94. The Need for Lambda Aliases
95. Lambda Aliases
96. Challenges with using Lambda Aliases
97. Stage Variables in API Gateway
98. Traffic Shifting between Lambda Versions using Aliases
99. Canary Deployments in API Gateway
100. Using Environment Variables in Lambda
101. Creating the KMS Encryption Keys
102. Encrypting Environment Variables using KMS
103. Running Lambda inside the VPC
104. Overview of Retry Behavior and DLQs in AWS Lambda
105. Error Retries and DLQs in Action
106. Setting up Lambda Dead Letter Queue using SQS
107. Testing Retry Behavior and DLQs in AWS Lambda
108. Container Reuse
109. Cold Starts in AWS Lambda
110. Dynamic Lambda Handlers
111. API Gateway Access Control Options (API Keys, Client Certificates, CORS)
112. Controlling API Gateway Access using CORS
113. Controlling API Gateway Access with Resource Policies
114. Controlling Access with Standard IAM Roles and Policies
115. Interactions between Resource Policies and IAM Policies
116. Creating Lambda Authorizers for API Gateway Access Control
117. Lambda Authorizers – Validating Authorization Tokens
118. Adding Lambda Authorizers to API Gateway Methods
119. Using Lambda Authorizer Context Object for Body Mapping in API Gateway
120. Creating AWS Cognito User Pools for API Gateway Authorization
121. Generating Auth Tokens with Cognito User Pools
122. Creating Cognito Authorizer in API Gateway
123. DynamoDB Streams and AWS Lambda Triggers
124. Serverless Deep Dive - AWS Step Functions
125. Fundamentals of AWS Step Functions
126. Creating your first State Machine using Amazon States Language (ASL)
127. Wait State in Step Functions
128. Task State in Step Functions
129. Input Processing and Filtering in State Machines
130. Output Processing and Filtering in State Machines
131. Other State Types in Step Functions (Fail, Succeed, Choice, and Parallel States)
132. Error Handling in Step Functions with Retry and Catch
133. Invoking State Machine with API Gateway
134. Invoking State Machine with CloudWatch
135. Invoking State Machine using AWS SDK
136. Step Functions Project – Build Image Processing Workflow with Step Functions
137. Image Processing Demo – Defining Branching Logic with Parallel State
138. Image Processing Demo – Defining S3 Trigger to Invoke State Machine
139. Image Processing Demo – Writing Backend Lambda functions
140. Image Processing Demo – Creating Image Resizer function
141. Image Processing Demo – Writing Metadata to DynamoDB
142. Image Processing Demo – Deleting Processed File
143. Image Processing Demo – Finishing the State Machine with Error Handling
144. Image Processing Demo – Finishing the State Machine with Error Handling (Contd.)
145. Image Processing Demo – Testing the State Machine Workflow
146. Accelerating Serverless Development with AWS SAM (Serverless Application Model)
147. What is AWS SAM?
148. Development with SAM - Creating Lambda Functions
149. Creating Your First SAM Template
150. Packaging and Deploying with SAM Template and CloudFormation
151. Testing the Deployed SAM Stack
152. Setting up the AWS SAM CLI
153. Configuring the Firewall for Docker on Windows
154. Creating a Boilerplate Serverless Project with AWS SAM CLI
155. Running Lambda Functions Locally with AWS SAM CLI
156. Running Lambda Functions Locally from within our Application Code
157. Generating Sample Lambda Event Payloads with SAM CLI
158. Running API Gateway Locally with AWS SAM CLI
159. AWS SAM Project - Building Serverless REST API with AWS SAM
160. Serverless REST API with AWS SAM - Finish the Lambda Code
161. Serverless REST API with AWS SAM - Writing the SAM Template
162. Serverless REST API with AWS SAM - Validating the SAM Template
163. Serverless REST API with AWS SAM - Packaging and Deploying with SAM CLI
164. Serverless REST API with AWS SAM - Testing and Updating Your SAM Application
165. Accessing Lambda Function Logs with AWS SAM
166. Accelerating Serverless Development with the Serverless Framework
167. What is the Serverless Framework?
168. Installing and Configuring the Serverless Framework
169. Creating Your First Serverless Application with the Serverless Framework
170. Testing the Lambda Functions Locally with the Serverless Framework
171. Deploying with the Serverless Framework
172. Removing a Deployed Stack using the Serverless Framework
173. Creating APIs using the Serverless Framework
174. Redeploying Single Lambda Function with the Serverless Framework
175. Configuring Global Properties with the Serverless Framework
176. VPC Configuration for Lambda Functions using the Serverless Framework
177. Serverless Plugins – Running API Gateway Locally using the Serverless Framework
178. Accessing CloudWatch Logs using the Serverless Framework
179. Lambda Integration and Body Mapping Templates using the Serverless Framework
180. Lambda Integration and Body Mapping Templates using the Serverless F/W (Contd.)
181. Testing the API Gateway Mappings
182. Automating Serverless Deployment with AWS CI/CD Tools
183. Using AWS CodeCommit for Source Control
184. Setting up a Local Git Repository
185. Using AWS CodeCommit for Source Control
186. Merging Git Branches and Pushing Updates to CodeCommit
187. Using AWS CodeBuild for Continuous Integration of Serverless Projects
188. Changes to the Serverless Framework Deployment Process
189. Defining the CodeBuild Build Specification File (buildspec.yml)
190. AWS CodeBuild in Action
191. Using AWS CodePipeline for Continuous Delivery of Serverless Projects
192. Adding Manual Approval before Production Deployment with AWS CodePipeline
193. Automated Production Deployment with AWS CodePipeline in Action
194. Testing the Production Deployment
195. AWS Serverless Architecture and Serverless Best Practices
196. Section Overview
197. AWS Lambda Best Practices
198. Amazon API Gateway Best Practices
199. Amazon DynamoDB Best Practices
200. Best Practices for AWS Step Functions

In this course, we will learn almost all the AWS Serverless Services with all aspects. We are going to build serverless applications with using

• AWS Lambda, Amazon API Gateway, Amazon DynamoDB, Amazon Cognito, Amazon S3, Amazon SNS, Amazon SQS, Amazon EventBridge, AWS Step Functions, DynamoDB and Kinesis Streams

• AWS Serverless Deployment Frameworks - IaC - Infrastructure as Code tools;

  • CloudFormation

  • AWS CDK

This course will be 100% hands-on, and you will be developing a real-world application with hands-on labs together and step by step, you can find main and sub topics;

Basics - Serverless Compute, APIs and Data Persistences

• AWS Lambda - Serverless, Event-driven Compute Service

• Amazon API Gateway - API-Driven Development for Synchronous Event Sources

• Amazon DynamoDB -  Data persistence with NoSQL Serverless Database

Authentication

• Amazon Cognito - Authentication and Authorization in Serverless

Storing & Hosting

• Amazon S3 - for Cloud Object Storage in order to store any type of data or deploy our web applications.

AWS Lambda Event-Driven Architectures and Invocation Types

• AWS Lambda Best Practices and Event-driven Architecture

• AWS Lambda - Asynchronous invocation

• AWS Lambda - Lambda event source mappings

Application Integrations Services; Asynchronous Event Sources - Event-based Architectures

• Amazon SNS  - Fully managed pub/sub messaging

• Amazon SQS - Fully managed message queues - Message Queues for cross-service communication using (AWS SQS)

• Amazon EventBridge - Decouple microservices with event-driven approaches

Application Orchestration Services

• AWS Step Functions - orchestrate microservices into serverless workflows.

SAGA Pattern and apply SAGA pattern with different approaches;

• Choreography-based SAGA with using Amazon EventBridge - which means Decouple microservices with events

• Orchestration-based SAGA with using AWS Step Functions - which means Decouple microservices with orchestration way

Streams and Polling Event Source mapping

• Amazon DynamoDB streams

• Amazon Kinesis Data streams

Serverless Deployment Frameworks - Cloud stack development with IaC

• CloudFormation -- Speed up cloud provisioning with infrastructure as code

• AWS CDK -- AWS Serverless Deployments IaC with AWS CDK (Cloud Development Kit)

Real-world Hands-on Labs:

We will develop almost 20 hands-on labs during the course. If we look at the some of the important hands-on labs of our course;

• Hands-on Lab: Single Calculator Microservice Expose https methods with Lambda Function Url

• Hands-on Lab: Build Serverless Chat App with a WebSocket API and Lambda

• Hands-on Lab: Building RESTful Microservices with AWS Lambda, API Gateway and DynamoDB

• Hands-on Lab: Secure your API Gateway with Amazon Cognito User Pools

• Hands-on Lab: Using an Amazon S3 trigger to invoke a Lambda function and persist on DynamoDB

• Hands-on Lab: Fan-Out Serverless Architectures Using SNS, SQS and Lambda

• Hands-on Lab: Process DynamoDB or Kinesis Streams using AWS Lambda for Change Data Capture of DynamoDB Tables

• Hands-on Lab: AWS Serverless Microservices for Ecommerce Application using Amazon EventBridge

• Hands-on Lab: Saga Pattern for Orchestrate Distributed Transactions using AWS Step Functions

Way of Learning:

This course is %100 hand-on course and include lots of development activities, that means we will develop codes for almost all AWS services and interactions.

For each AWS serverless services we will have 4 main part;

1. Theorical Information

   1. AWS Service overview, core concepts, features, uses cases and general information

2. Walkthrough with AWS Management Console

   1. AWS Service Walkthrough with AWS Management Console performs main use cases

3. Developing with AWS SDK

   1. AWS Service Programmatic Access interaction with Serverless APIs using AWS SDK or CLI

4. Hands-on Labs with Real-World Use Cases

   1. AWS Service Hands-on Labs implementation with Real-World Use Cases

These are 4 main topics that we are going to handle almost all AWS Serverless services. By this way we can cover for all aspects of any particular AWS services.

In the course structure, when we finished any AWS Serverless services, we have at least 1 hands-on lab for particular AWS services. For example if we finished Amazon SQS sections and understand the service, we will have several hands-on labs like Fan-out pattern implementations with Amazon SNS, or decouple microservices with Amazon EventBridge and so on. These will mostly includes combination of other AWS services that represents real-word applications.

And also in the last sections, we will see how we can do Cloud stack development - IaC with Serverless Deployment Frameworks for any particular AWS Serverless services. Develop infrastructure for all AWS services and perform interactions with coding interactions.

AWS Developer and AWS Solution Architecture Jobs

This course prepares to you real AWS Developer and AWS Solution Architecture jobs, which's offers to you 3 figure salaries.

Because we are going to develop a Real-world Serverless application which is already used and developed by lots of companies in the world.

Prepare your AWS Certification with Practical Way

• AWS Certified Developer Associate

• AWS Certified Solutions Architect Associate

Don't memorize all topics, feel and develop by hands-on, dirty your hands by this way you can achieve to onboard your target AWS jobs. This course will help you to prepare AWS Developer and Solutions Architect Associate certifications both theoretical and mostly practical way with developing Serverless applications.

By the end of this course, you'll learn how to design and developing AWS Serverless services with real-world hands-on project following the best practices.

You don't need any prior knowledge before the course I will explain both theoretical information and practical developments.

This course is Developer Guide so that means; the course will be includes %100 of hands-on development activities, mostly we will develop lambda functions with different use cases and integrations. All course steps will be developed step by step and together.

1. Introduction
2. Introduction
3. Hands-on Labs with Real-World Use Cases
4. Serverless Explanained : AWS Operational Responsibility Model
5. AWS Serverless Services and Way of Learning
6. AWS Cost Management During the Course
7. Project Code & Course Slides
8. Project Code & Course Slides
9. Project Code Structure
10. How to follow the Course
11. Create AWS Account - Free Tier
12. Create Free Tier AWS Account
13. Security Best Practices of AWS Accounts
14. Create IAM User Account and Configure for Programmatic and Console Access
15. AWS Access Types - Programmatic and Management Console Access
16. AWS Lambda - Serverless, Event-driven Compute Service
17. What is AWS Lambda?
18. How does AWS Lambda work?
19. AWS Lambda Main Features
20. AWS Lambda Event Sources and Destination Trigger Services
21. AWS Lambda Invocation Types
22. AWS Lambda Function Code
23. AWS Lambda Execution Environment
24. Configuring AWS Lambda Functions
25. Concurrency on AWS Lambda - Reserved and Provisioned Concurrency
26. AWS Lambda Permissions; Execution Role and Resource-based Policies
27. AWS Lambda Quiz
28. AWS Lambda - Walkthrough with AWS Management Console
29. Getting Started with AWS Lambda and How Lambda Works
30. Create our First AWS Lambda Function with AWS Management Console
31. Test AWS Lambda Function with AWS Management Console
32. Configurations of AWS Lambda Function with AWS Management Console
33. Logs of AWS Lambda Function with AWS Management Console
34. Change AWS Lambda Function Code on AWS Management Console
35. Create AWS Lambda Function with No-BluePrint with AWS Management Console
36. Upload zip file for Lambda Function with AWS Management Console
37. Clean up Resources
38. Prerequisites and Tools for developing Serverless Applications on AWS
39. Introduction - Prerequisites and Tools
40. Prerequisites 1 - AWS Account and User
41. Prerequisites 2 - AWS CLI
42. Quick Setup of AWS CLI
43. Prerequisites 3 - NodeJS
44. Check our Installations
45. Prerequisites 4 - Visual Studio Code
46. Prerequisites 5 - Postman
47. AWS Lambda - Developing with AWS CLI - Programmatic Access w/ Serverless APIs
48. Introduction - AWS Lambda - Developing with AWS CLI - Programmatic Access
49. Course Folder Structure and Create Project Directory
50. Using AWS Lambda with the AWS CLI
51. Invoking Lambda functions with the AWS CLI
52. Invoking Lambda functions with passing event.json file using AWS CLI
53. Create AWS Lambda functions with AWS CLI
54. Create Execution Role for Lambda functions with AWS CLI
55. Develop AWS Lambda function handler in Node.js
56. Deploy Node.js Lambda Functions with .zip File Archives
57. Create AWS Lambda function with .zip file using AWS CLI
58. Invoking Lambda functions with passing event.json file using AWS CLI
59. AWS Lambda CloudWatch Logs using AWS CLI
60. Update AWS Lambda Function Code using AWS CLI
61. Update AWS Lambda Function with Additional Dependencies using AWS CLI
62. AWS Lambda Context Object in Node.js Function
63. AWS Lambda Function Logging in Node.js Example
64. AWS Lambda Function Errors in Node.js Example
65. Using AWS Lambda Environment Variables
66. Clean up Resources - Delete AWS Lambda Functions
67. AWS Lambda - Working with Events
68. AWS Lambda Best Practices and Event-driven Architecture
69. Understanding How Lambda Trigger with Event Json Object
70. Understanding How Lambda Trigger with Event JSON Object Part 2
71. Hands-on Lab: Greeting Project
72. Hands-on Lab: Calculator Project
73. AWS Lambda Trigger Events and Test Templates
74. AWS Lambda Invocation Types
75. AWS Lambda Asynchronous Invocation using AWS CLI
76. AWS Lambda Function URLs: Built-in HTTPS urls for Single-Function Microservice
77. AWS Lambda Function URLs: Built-in HTTPS urls for Single-Function Microservice
78. Using AWS Lambda as a Microservice
79. Creating and Managing AWS Lambda Function URLs w/ Console
80. Reviewing and Invoking AWS Lambda Function URLs w/ Console
81. Understand Incoming Event When Invoking AWS Lambda Function URLs
82. Update Function Code for Incoming Event When Invoking AWS Lambda Function URLs
83. Hands-on Lab: Single Calculator Microservice Expose https methods with Lambda
84. When to use Function URLs vs. Amazon API Gateway
85. Amazon API Gateway - API-Driven Development for Synchronous Event Sources
86. Introduction - API Gateway Restful API Development with Synchronous Lambda Event
87. What is Amazon API Gateway?
88. Architecture of API Gateway
89. Main Features of API Gateway
90. Amazon API Gateway Use Cases
91. API Gateway as a Lambda Synchronous Event Sources
92. Amazon API Gateway Core Concepts
93. Amazon API Gateway -Differences between REST - HTTP API
94. API Gateway Quiz
95. API Gateway - HTTP API - Walkthrough with AWS Management Console
96. Introduction - API Gateway - HTTP API - Walkthrough with AWS Management Console
97. API Gateway - HTTP API - Core Concepts; Routes
98. API Gateway - HTTP API - Core Concepts; Integrations
99. API Gateway - HTTP API - Core Concepts; Stages
100. Getting Started with API Gateway - HTTP APIs
101. Hands-on Lab: Build CRUD Microservice with HTTP API and Lambda
102. Hands-on Lab: Build CRUD Microservice - Create HTTP API
103. Understanding How HTTP API Trigger Lambda with Event Json Object
104. Develop Lambda Function for Incoming HTTP API Event Json Object
105. E2E Test HTTP API and Lambda Function with Incoming HTTP API Event Json Object
106. Clear Resources
107. API Gateway - REST API - Walkthrough with AWS Management Console
108. Introduction - API Gateway - REST API - Walkthrough with AWS Management Console
109. API Gateway - REST API - Core Concepts; Resources, Methods, Stages, Authorizers
110. Getting Started with API Gateway - REST APIs
111. Enable Request validation in API Gateway - REST API
112. Hands-on Lab: Build CRUD Microservice with REST API and Lambda
113. Hands-on Lab: Build CRUD Microservice - Create REST API
114. Understanding How REST API Trigger Lambda with Event Json Object
115. Develop Lambda Function for Incoming REST API Event Json Object
116. E2E Test REST API and Lambda Function with Incoming REST API Event Json Object
117. Alternative Way to Create a REST API from AWS Lambda Function
118. Clear Resources
119. API Gateway - WebSocket API - Walkthrough with AWS Management Console
120. Introduction - API Gateway - WebSocket API - Walkthrough with AWS Console
121. API Gateway - WebSocket API - Core Concepts; Routes, Integrations, Stages
122. Getting started with API Gateway - WebSocket APIs
123. Hands-on Lab: Build Serverless Chat App with a WebSocket API and Lambda
124. Hands-on Lab: Build Serverless Chat App - Create WebSocket API
125. Understanding How WebSocket API Trigger Lambda with Event Json Object
126. Develop Lambda Function for Incoming WebSocket API Event Json Object
127. E2E Test WebSocket API and Lambda Function with Incoming WebSocket API Event obj
128. Clear Resources
129. Amazon DynamoDB - Serverless NoSQL Data Persistence
130. What Is Amazon DynamoDB?
131. AWS DynamoDB Core Concepts - Tables, Items, Attributes, Indexes
132. AWS DynamoDB Primary Key, Partition Key and Sort Key
133. Amazon DynamoDB Partitions and Data Distribution with Partition Key and Sort Key
134. Amazon DynamoDB Read Consistency, CAP Theorem and Eventual Consistency
135. Amazon DynamoDB Read and Write Capacity Mode
136. Amazon DynamoDB API References
137. Amazon DynamoDB PartiQL - A SQL-Compatible Query Language for DynamoDB
138. Accessing DynamoDB with Different Ways
139. Amazon DynamoDB Quiz
140. Amazon DynamoDB - Walkthrough with AWS Management Console
141. Introduction - Amazon DynamoDB Walkthrough with AWS Management Console
142. Create our First Amazon DynamoDB Table with AWS Management Console
143. Write an Item into Amazon DynamoDB Table with AWS Management Console
144. Read Data - Scan Command - from Amazon DynamoDB Table with AWS Console
145. Read Data - Query Command - from Amazon DynamoDB Table with AWS Console
146. Update Data from Amazon DynamoDB Table with AWS Management Console
147. Create a Global Secondary Index on Amazon DynamoDB Table with AWS Console
148. Query the Global Secondary Index on Amazon DynamoDB Table with AWS Console
149. Query Data using PartiQL Editor from Amazon DynamoDB Table with AWS Console
150. Clear Resources
151. Amazon DynamoDB Walkthrough with AWS CLI
152. Introduction - Amazon DynamoDB Walkthrough with AWS CLI
153. Create DynamoDB Table with AWS CLI
154. Write Data into DynamoDB Table with AWS CLI
155. Read Data into DynamoDB Table with AWS CLI
156. Update Data into DynamoDB Table with AWS CLI
157. Query Data into DynamoDB Table with AWS CLI
158. PartiQL CRUD Operations into DynamoDB Table with AWS CLI
159. Clear Resources
160. Hands-on Lab: Build RESTful Microservices with AWS Lambda, Api Gateway, DynamoDB
161. Intoductuction - RESTful Microservices with AWS Lambda, Api Gateway and DynamoDb
162. Create a DynamoDB Table
163. Create a Lambda Function
164. Create an API Gateway
165. Test - RESTful Microservices with AWS Lambda, Api Gateway and DynamoDb
166. AWS Console microservice-http-endpoint Lambda Blueprint - Api Gw + Lambda + DB
167. Resource Cleanup
168. NodeJS Basics - Recap NodeJS
169. Why we need to know NodeJS Basics ? Skip or Continue ?
170. NodeJS Basics and Installment
171. Running Node Command
172. Run NodeJS Functions
173. Passing Arguments to NodeJS Functions
174. NodeJS Modules
175. NPM - Node Package Manager and Use npm packages into NodeJS
176. NodeJS Quiz
177. AWS SDK for JavaScript - Developer Guide for SDK Version 3
178. What is AWS SDK ?
179. AWS SDK for JavaScript Version 3 and using SDK with Node.js
180. What's new in AWS SDK for JavaScript Version 3 and Cold Start Benefit
181. Important - ECMAScript 6 (ES6) Requirements
182. Using Node.js ES modules and top-level await in AWS Lambda
183. Amazon DynamoDB - Developing with AWS SDK- Programmatic Access w/ Serverless API
184. Introduction - Amazon DynamoDB SDK Examples
185. Understanding DynamoDb Interactions - Working with Items and Attributes
186. Create NodeJS Project with DynamoDB SDK Packages
187. Create DynamoDBClient NodeJS Module For Connecting DynamoDB
188. Creating a DynamoDB Table
189. Listing DynamoDB Tables
190. Describing DynamoDB Table
191. Deleting DynamoDB Tables
192. Reading and writing a Single item in DynamoDB Table
193. Writing an Item into DynamoDB Table
194. Update an Item into DynamoDB Table
195. Getting an Item into DynamoDB Table
196. Deleting an Item into DynamoDB Table
197. Writing Items in Batch into DynamoDB Table
198. Reading Items in Batch into DynamoDB Table
199. Querying and Scanning a DynamoDB table
200. Querying a DynamoDB Table

[Oct 2023] Added Gen AI Demo with Lambda and Amazon Bedrock

[Dec 2022] Added Re:Invent 2022 Updates

[Nov 2021] Updated with all newest features - Lambda Container Image, re:Invent 2020 Changes, Step Function Visual Workflow, EFS Lambda, RDS Proxy, Custom Domain, HTTP API with Demos, EventBridge Deep Dive

Serverless computing is the future of Cloud Computing. You can deploy AWS Lambda functions in Amazon Web Services that infinitely scale without managing any servers! Serverless is the tool that you need to grow your career.

How is this course different?

This course will teach you the ENTIRE Serverless ecosystem. We will start with:

• Understand, Develop and Deploy AWS Lambda

• Create REST APIs using Lambda and API Gateway

• Learn DevOps and entire AWS CI/CD Services (CodeCommit, CodeBuild, CodeDeploy, Code Pipeline, CodeStar)

• AWS SAM (Serverless Application Model)

• Serverless Vs Container

• The Serverless Framework

• Serverless Best Practices and Architecture Patterns

  
  

But it doesn't stop there. We will learn:

• Debugging and Pair Programming using AWS Cloud9

• Tracing using X-Ray, CloudWatch Log Insights to gain performance insights on our Lambdas and APIs

• Lambda Layers

• Ways to secure our design with in-depth lectures and demo. This includes:

  • API Key and Usage Plans

  • AWS Cognito User Pools

  • AWS Secrets Manager

  • Lambda Resource Policies

  • Lambda Authorizer (Custom Authorizer)

  • API Gateway Resource Policies

  • Encrypting data using CMK (Customer Managed Keys)

  • And more!

• Other relevant AWS Services such as Step Functions, Comprehend etc

• Databases that complement Serverless - DynamoDB and Serverless Aurora

• A real world news sentiment analysis project

• Limitations of Serverless (Yes, there are indeed some!)

• And much much more!

About the instructor

Rajdeep Saha is a Principal Solutions Architect at AWS. He has migrated and designed numerous mission-critical apps in the cloud, handling millions of transactions. Rajdeep has presented at the biggest stages, such as AWS Re:Invent, AWS Summits, and Kubecon. He has authored multiple bestselling courses and mentored students successfully to cloud jobs, including FAANG companies. Rajdeep also runs a successful YouTube channel named "Cloud With Raj" with over 100K+ subscribers. He has over 250,000+ followers across the globe. Rajdeep takes pride in teaching real-world solutions and learnings beyond just theoretical information. You are in capable hands! All opinions are Rajdeep's own.

This is the course that could take your career to next level. Serverless is the way of future and you can get started today and become an expert.

Let's have some fun and build some awesome stuff in cloud together!

1. Getting Started
2. Introduction
3. Understanding Serverless - Datacenter Vs EC2 Vs Lambda
4. Lambda Deeper Look
5. How Much Does Lambda Cost?
6. Creating and Testing Our Very First Lambda
7. S3 Images Triggering Lambda
8. Ways to Create Lambda
9. Optional: Understanding IAM Group, Policy, User and Role together
10. Is This Service Serverless???
11. It's Your Turn Now!
12. Course Slides
13. API Gateway
14. Understanding API with Real World Example
15. What is AWS API Gateway
16. Creating API with Lambda Integration
17. Creating a POST API
18. Installing Postman And Calling Our API
19. API Gateway Components
20. What are Query Parameters
21. Demo of Query Parameters
22. AWS Cross Account Call in API Gateway
23. Lambda Version and Alias for API Traffic Splitting
24. API Traffic Splitting Using Lambda Alias
25. Canary Deployment of API
26. API Endpoint Types
27. API Endpoint Demo
28. API Caching
29. Swagger for API - What and Why
30. Exporting and Creating APIs using Swagger
31. CORS (Cross Origin Resource Sharing)
32. HTTP API Vs Rest API
33. HTTP API Demo
34. API Gateway Custom Domain - What and Why
35. API Gateway Custom Domain Demo
36. Lambda Advanced Concepts
37. Lambda Scaling, Concurrency, And Provisioned Concurrency
38. Lambda Environment Variables
39. Lambda External Dependencies
40. Demo of External Dependency Problem
41. Solving External Dependencies using Visual Studio Code
42. Solving External Dependencies using Cloud9
43. REINVENT 2020 RELEASE - Lambda Container Images - Deep Dive and Demo
44. Lambda Layers - What and Why
45. Lambda Layers - Demo
46. EFS Integration with Lambda
47. Demo - EFS Integration with Lambda
48. Serverless Repository
49. Lambda Destinations
50. RDS Proxy - What and Why
51. Demo - RDS Proxy
52. Code Any Boto3
53. SNS And SQS Deep Dive
54. SNS Message Filtering
55. EventBridge And EventBus
56. Custom EventBridge Event Bus and Rules
57. Updated - EventBridge vs SQS vs SNS
58. New - EventBridge Pipes
59. Step Functions
60. AWS Step Functions - What And Why
61. Standard Vs Express Step Functions
62. Step Functions Upgraded Console
63. New - Step Function Visual Workflow
64. Nested Step Functions - What and Why
65. Demo - Nested Step Function
66. Advanced: Service Integration - Request Response, Sync, Callback, Activity
67. Serverless Logging And Monitoring
68. Lambda Logging And Monitoring
69. Monitoring API using Cloudwatch Metrics
70. CloudTrail Vs CloudWatch Logging
71. Demo of API CloudTrail Logging
72. API CloudWatch Logging - Beyond The Basic
73. Demo of CloudWatch Logging for API
74. CloudWatch Logs Insight
75. AWS X-Ray Introduction
76. Tracing API Gateway Using X-Ray
77. Lambda Basic Tracing Using X-Ray
78. Lambda Advanced Tracing using Subsegments
79. AWS CLI
80. What is AWS CLI?
81. Different Ways to Use AWS CLI
82. Setting Up AWS CLI using EC2
83. Creating Lambda from EC2 AWS CLI
84. The Easy Way to AWS CLI - Cloud9
85. Invoking Lambda from AWS CLI
86. Updating Lambda from AWS CLI
87. Cloudshell - New Way to AWS CLI
88. Creating, Exploring, Downloading Lambda in Cloud9
89. Security - API Gateway And Beyond
90. Security Section Introduction
91. Why Secure our APIs
92. Introduction to API Key
93. API Key in Action
94. Securing API Using AWS_IAM
95. Security Using Cognito User Pool
96. Securing API with Cognito User Pool Demo with Hosted UI
97. Cognito Identity Pool Vs AWS_IAM Vs Cognito User Pool
98. Exploring Cognito Identity Pool in Console
99. AWS Secrets Manager - What And Why
100. AWS Secrets Manager Demo
101. Lambda Resource Policy - What And Why
102. Securing API with Lambda Resource Policy - Demo
103. Lambda Authorizer in API Gateway
104. API Gateway Resource Policy
105. Demo of API Gateway Resource Policy
106. New - Lambda Scanning with Inspector
107. Storage For Serverless
108. SQL Vs NoSQL Database
109. Issue with Lambda And Traditional Database
110. DynamoDB - Super High Level Overview
111. DynamoDB Core Components
112. Creating Table in DynamoDB
113. Inserting into DynamoDB from Lambda
114. Deleting from DynamoDB using Lambda
115. DynamoDB Secondary Index
116. Global Tables
117. Read Consistency And Write Capacity
118. Demo of Strongly Consistent Read
119. New Feature: DynamoDB On Demand
120. DynamoDB Mega Demo - Tying It All Together
121. DynamoDB Streams
122. DynamoDB Encryption
123. Encryption Of Data using CMK In Lambda
124. Serverless Aurora Demo
125. Gen AI Serverless Demo (NEW!!)
126. Amazon Bedrock and Serverless Demo
127. Real World Serverless Project - News Sentiment Analysis
128. Real World Project Overview
129. Building the First Part
130. AWS Comprehend Introduction
131. Deploying and Testing the First Part
132. Building CloudWatch Event Rule for Lambda
133. First Part Recap
134. Building Lambda for News Fetch API
135. Creating the API in API Gateway
136. Securing the API
137. Final Words on Real World Lambda Project
138. DevOps for Serverless (New!)
139. DevOps for Serverless - A Word from Your Instructor
140. DevOps - What and Why?
141. DevOps Phases & Difference Between Continuous Delivery and Continuous Deployment
142. Why DevOps on AWS?
143. What is AWS CodeCommit
144. AWS CodeCommit Demo - Our Very First Commit
145. AWS CodeCommit - Notification and Triggers
146. AWS CodeCommit - Branch and Pull Request Demo
147. What is AWS CodeBuild & Difference With Jenkins
148. How AWS CodeBuild Works Under The Hood?
149. Different Lambda CI/CD Flows
150. AWS CodeBuild Buildspec File
151. AWS CodeBuild Demo
152. Lambda CI/CD - Lambda Deployer
153. Lambda CI/CD End To End Demo
154. What is AWS CodeDeploy
155. Lambda and CodeDeploy
156. AWS CodeDeploy AppSpec file
157. AWS CodeDeploy Revision
158. CodeDeploy Key Deployment elements
159. AWS CodeDeploy Lambda Demo
160. AWS CodePipeline Intro
161. AWS CodePipeline - Console Look and Feel
162. AWS CodePipeline Demo - Simple EC2 Application
163. AWS CodePipeline Demo - Serverless End to End
164. Quick Chat about CodePipeline Serverless Flow Demo
165. Automate Unit Testing in CodePipeline
166. AWS CodeStar - What and Why
167. Deploying and Changing Serverless Patterns using CodeStar
168. AWS SAM (Serverless Application Model)
169. SAM Lectures Update In Progress!
170. AWS SAM - What and Why
171. Deploying Our First SAM Template
172. Deploying Basic Lambda with SAM
173. Local Testing Lambda with External Dependency
174. Deploying Lambda with External Dependency
175. SAM and Regular CloudFormation
176. Lambda Events
177. S3 triggering Lambda using SAM
178. Creating API and Lambda Events using SAM
179. Creating Scheduled Lambda using SAM
180. Using Swagger File in SAM
181. Creating API with Swagger and Pre-existing Lambda
182. Creating API with Swagger and New Lambda in SAM
183. Serverless Frameworks
184. Different Serverless Frameworks - What and Why
185. Should I use Third-Party Frameworks?
186. The Serverless Framework - Intro
187. Installing The Serverless Framework
188. Setting up Creds from Serverless Dashboard
189. Setting up Creds from Terminal using AWS Configure
190. Installing Serverless Framework in Cloud9
191. Creating Lambda and API using Serverless Framework
192. Creating an App Backend using Serverless Framework
193. Serverless Framework Dashboard
194. Exploring Serverless.yml File
195. AWS SAM Vs The Serverless Framework
196. Serverless Vs Container
197. Serverless Vs Container
198. AWS Fargate - Serverless AND Container Together!
199. Advanced+Optional: ECS Vs EKS Vs Fargate
200. Advanced+Optional: AWS Fargate Demo - Serverless + Container

Ever felt like you would like to build a back-end application that can handle millions of users, but you were terrified by the idea of managing (or learning how to manage) the infrastructure behind it?

Ever felt like you would like to focus on delivering valuable features, rather than making sure your services are up and running?

Ever felt like you are paying more than you should be?

Good news!

Serverless Architecture takes the pain of site reliability off your shoulders. With Serverless Architecture, you and your team can focus on feature development. Your application will scale effortlessly, serving users reliably. You do not need to be an infrastructure expert to serve an application at scale. With Serverless, you only pay for what you use.

Serverless Framework revolutionizes the way we develop Serverless applications, by providing a developer-friendly API that supports dozens of cloud providers including Amazon Web Services, Google Cloud Platform, Microsoft Azure, and more.

More than that, Serverless Framework intelligently helps you manage your infrastructure as code (IaC), which eliminates the chance of paying for services that are not in use.

With an active community and a rich ecosystem of plugins, you can get things done at lightspeed and without boilerplate code.

Serverless Framework is language-agnostic, which means you can use the language and runtime of your choice (Node.js, Ruby, Python, Go, C#, Java, etc).

With over 450,000 downloads per week and x5 growth over the past two years, demand for Serverless experts is on the rise. It is one of the most in-demand skills in the market.

___

In this course, you will learn how to develop reliable and scalable Serverless applications, following the microservices architecture. This course will be 100% hands-on, and you will be developing a real-world application;

• REST API and CRUD endpoints (AWS Lambda, API Gateway)

• Data persistence (AWS DynamoDB)

• Message Queues for cross-service communication (AWS SQS)

• Scheduled event triggers (AWS EventBridge)

• Cloud stack management (AWS CloudFormation)

• Object storage on the cloud (AWS S3)

• Email notifications (AWS SES)

• Middleware

• Authentication and Authorization (Lambda Authorizer)

• Data validation and error handling

• ... much more

Besides that, you will get hands-on experience with some of the most popular and useful services on the AWS platform. Demand for AWS experts is continuously on the rise, as AWS holds the biggest stake amongst all cloud providers.

If you are a hobbyist or professional developer with basic back-end development knowledge and want to dive into Serverless or Microservices architecture, this course is for you. Basic JavasScript/Node.js background is recommended, but not mandatory.

Join me today to learn one of the hottest skills in 2020.

1. Course Introduction
2. Project Overview
3. Serverless Architecture in a Nutshell
4. Introduction to Serverless Framework
5. Real-world Serverless Use Cases
6. More Valuable Content
7. Introduction to Microservices Architecture
8. AWS Free Tier
9. Requirements and Prerequisites
10. Installing Node.js and NPM
11. Installing the AWS CLI
12. Installing the Serverless Framework CLI
13. Configuring the AWS CLI + IAM
14. (Optional) AWS Budgets and Alerts
15. My Postman Setup
16. Auction Service: Part 1
17. Let's Connect!
18. Creating a Serverless Framework Project
19. The Anatomy of a Serverless Project
20. TIP: Serverless IDE VSCode Plugin
21. Deploying Our Application for the First Time
22. (Tip) Stack Removal
23. Creating an Auction (Part 1)
24. Creating an Auction (Part 2)
25. NOTE: Introduction to DynamoDB
26. Introduction to DynamoDB
27. Creating our DynamoDB Table (IaaC)
28. Using the DynamoDB DocumentClient to Insert an Auction
29. Defining IAM Role Statements (Permissions)
30. Optimising serverless.yml (Part 1): Roles and IAM Statements
31. Optimising serverless.yml (Part 2): Intrinsic Functions and Custom Variables
32. Serverless Offline - Is It Worth It?
33. Auctions Service: Part 2 (CRUD Operations)
34. Introduction to Middy and Middleware
35. CRUD Operation: Get Auctions
36. CRUD Operation: Get Auction by ID
37. Creating a Common Middleware
38. CRUD Operation: Placing a Bid
39. Validation: Placing a Bid
40. Auction Service: Part 3 (Processing Auctions)
41. Using Scheduled Events to Process Our Auctions
42. Creating a Global Secondary Index (status, endingAt)
43. Identifying Ended Auctions
44. Closing Auctions
45. Validation: Bidding on Closed Auctions
46. (Challenge) Getting Auctions - Filter by Status
47. IMPORTANT: Schema Validation
48. JSON Schema Validation - Get Auctions Status
49. (Optional) Detailed Error Messages
50. (Challenge) Create Auction Schema Validation
51. (Challenge) Place Bid Schema Validation
52. Auth Service
53. Section Introduction
54. Introduction to Auth0
55. Creating an Auth0 Application
56. Getting Test Tokens
57. Deploying Auth Service
58. Protecting Auction Service Endpoints
59. Specifying Seller Identity
60. Specifying Bidder Identity (+Validation)
61. Notification Service
62. Notification Service Setup
63. Reminder: Linting Disabled
64. Verify Email Address (AWS SES)
65. Defining the sendMail Lambda Function
66. Sending Our First (Test) Email
67. Introduction to SQS and Message Queues
68. Provisioning AWS SQS Message Queue (MailQueue)
69. Manually Sending SQS Messages
70. Exporting MailQueue Variables (CloudFormation)
71. Importing Outputs in Auction Service
72. Notifying Bidder and Seller
73. (Challenge) Handling No Bids Case
74. (Optional) Uncommenting EventBridge Trigger
75. Auction Picture (Amazon S3)
76. Setting up an S3 Bucket and Lambda Function
77. (Optional) Amazon S3 Picture Expiry
78. Uploading Picture to S3
79. Quick Error Handling Fix
80. Setting Picture URL in DynamoDB
81. (Challenge) Validate Auction Ownership
82. (Challenge) Validate Request Body (base64)
83. Moving Forward & Future Content
84. (Bonus) Front-end Application
85. Front-end Demo
86. Enabling CORS on Auction Service
87. Setting up the Auctions Front-end