Outlecture
Home
About
Technology
Design
Video
Contact
Official
日本語
Outlecture
Home
About
Technology
Design
Video
Contact
Twitter Official
  • Home
  • Technology

Top 8 Recommended Serverless Framework Self-Study Materials! [September 2023]

Last updated: Sep 8th, 2023

This page introduces the best in educational materials for beginners who are trying to learn Serverless Framework on their own.

Table of Contents:

1. Description of this page

1. Description of this page

We introduce 8 recommended video courses on various platforms for those who want to learn Serverless Framework on their own.

What is Serverless Framework?

Serverless Framework is an open-source framework that simplifies serverless application development. It supports serverless platforms such as AWS Lambda, Azure Functions, and Google Cloud Functions. It provides features such as code deployment, automatic scaling, log collection, and application monitoring.

Our site, "Outlecture," evaluates courses using our proprietary algorithm that balances course rating, freshness of information, number of purchasers and viewers, and recent rate of increase, in order to extract only the most suitable courses for users.

In addition, we will explain the features of each video platform and provide use cases such as "this is better for people in this situation."

We hope this will be a reference for everyone who is going to learn Serverless Framework.

2. Top 5 Recommended Udemy Courses

Here are Outlecture's top 5 recommended Udemy courses, carefully selected for you.

Title Ratings Subscribers Subscribers last month
(August 2023)
Level Video Duration Created Last updated Price

AWS Lambda & Serverless Architecture Bootcamp (Build 5 Apps)

thumbnail
4.43 41,468 511 all 25 hours 23 minutes May 14th, 2018 Jun 30th, 2023 $99.99

AWS Lambda & Serverless - Developer Guide with Hands-on Labs

thumbnail
4.61 4,125 365 beginner 28 hours 32 minutes Jun 29th, 2022 Jun 6th, 2023 $84.99

AWS Lambda and the Serverless Framework - Hands On Learning!

thumbnail
4.51 60,988 467 beginner 10 hours 28 minutes Jun 4th, 2017 Jul 1st, 2022 $94.99

The Complete Guide to Build Serverless Applications on AWS

thumbnail
4.49 4,894 234 all 26 hours 32 minutes Apr 27th, 2022 Jun 10th, 2023 $79.99

Master AWS Lambda: Go Serverless with AWS

thumbnail
4.66 5,402 - all 12 hours 14 minutes Sep 19th, 2020 May 4th, 2023 $89.99

Udemy, Inc. is an education technology company that provides the world's largest online learning and teaching platform.

The features of Udemy include:

  • Over 155,000 course
  • Instructors who are leading experts in their fields
  • Affordable prices range from tens to hundreds of dollars per course, with discounts of up to 70-90% during campaigns
  • Courses can be viewed without expiration after purchase, and come with a 30-day money-back guarantee
  • Courses can be taken at the student's own pace, with playback speeds of 0.5 to 2 times normal speed, and can be viewed offline on a smartphone with a dedicated app
  • Students can ask questions directly to the instructor on the course discussion board, allowing them to resolve any doubts and receive support for self-study

These are some of the benefits of using Udemy.

The management team at Outlecture consists of active software engineers, creators, and web designers. We often catch up on learning new programming languages and products by taking courses on Udemy.
As for our experience, we find that Udemy offers courses of very high quality. The instructors are all leading figures in their fields, and they teach cutting-edge knowledge and practical know-how in a clear and detailed manner. You can acquire the knowledge and skills that are actually used in the field and in practical projects, rather than just knowledge for exams.

We highly recommend Udemy courses, especially for those who want to apply what they learn in practical situations or for those who want to start self-studying. Once you purchase a course, you can take it without a time limit, and there is a 30-day money-back guarantee, so you can start learning with peace of mind.

Recommended for

  • Planning to use Serverless Framework in actual projects
  • Wanting to learn the know-how of professionals who are active in the world's cutting-edge fields
  • Hesitant to use a subscription service
  • Having basic IT knowledge

The details of each course are as follows:


AWS Lambda & Serverless Architecture Bootcamp (Build 5 Apps)

AWS Serverless with AWS Lambda, API Gateway, Amazon DynamoDB, Step Functions, SAM, the Serverless Framework, CICD & more

thumbnail
Ratings
4.43
Subscribers
41,468
Subscribers last month
(August 2023)
511
Level
all
Video Duration
25 hours 23 minutes
Created
May 14th, 2018
Last updated
Jun 30th, 2023
Price
$99.99

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. AWS Console Updates
  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
AWS Lambda & Serverless - Developer Guide with Hands-on Labs

Develop thousands line of AWS Lambda functions interact to AWS Serverless services with Real-world Hands-on Labs

thumbnail
Ratings
4.61
Subscribers
4,125
Subscribers last month
(August 2023)
365
Level
beginner
Video Duration
28 hours 32 minutes
Created
Jun 29th, 2022
Last updated
Jun 6th, 2023
Price
$84.99

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 - HTTP API - Walkthrough with AWS Management Console
  95. Introduction - API Gateway - HTTP API - Walkthrough with AWS Management Console
  96. API Gateway - HTTP API - Core Concepts; Routes
  97. API Gateway - HTTP API - Core Concepts; Integrations
  98. API Gateway - HTTP API - Core Concepts; Stages
  99. Getting Started with API Gateway - HTTP APIs
  100. Hands-on Lab: Build CRUD Microservice with HTTP API and Lambda
  101. Hands-on Lab: Build CRUD Microservice - Create HTTP API
  102. Understanding How HTTP API Trigger Lambda with Event Json Object
  103. Develop Lambda Function for Incoming HTTP API Event Json Object
  104. E2E Test HTTP API and Lambda Function with Incoming HTTP API Event Json Object
  105. Clear Resources
  106. API Gateway - REST API - Walkthrough with AWS Management Console
  107. Introduction - API Gateway - REST API - Walkthrough with AWS Management Console
  108. API Gateway - REST API - Core Concepts; Resources, Methods, Stages, Authorizers
  109. Getting Started with API Gateway - REST APIs
  110. Enable Request validation in API Gateway - REST API
  111. Hands-on Lab: Build CRUD Microservice with REST API and Lambda
  112. Hands-on Lab: Build CRUD Microservice - Create REST API
  113. Understanding How REST API Trigger Lambda with Event Json Object
  114. Develop Lambda Function for Incoming REST API Event Json Object
  115. E2E Test REST API and Lambda Function with Incoming REST API Event Json Object
  116. Alternative Way to Create a REST API from AWS Lambda Function
  117. Clear Resources
  118. API Gateway - WebSocket API - Walkthrough with AWS Management Console
  119. Introduction - API Gateway - WebSocket API - Walkthrough with AWS Console
  120. API Gateway - WebSocket API - Core Concepts; Routes, Integrations, Stages
  121. Getting started with API Gateway - WebSocket APIs
  122. Hands-on Lab: Build Serverless Chat App with a WebSocket API and Lambda
  123. Hands-on Lab: Build Serverless Chat App - Create WebSocket API
  124. Understanding How WebSocket API Trigger Lambda with Event Json Object
  125. Develop Lambda Function for Incoming WebSocket API Event Json Object
  126. E2E Test WebSocket API and Lambda Function with Incoming WebSocket API Event obj
  127. Clear Resources
  128. Amazon DynamoDB - Serverless NoSQL Data Persistence
  129. What Is Amazon DynamoDB?
  130. AWS DynamoDB Core Concepts - Tables, Items, Attributes, Indexes
  131. AWS DynamoDB Primary Key, Partition Key and Sort Key
  132. Amazon DynamoDB Partitions and Data Distribution with Partition Key and Sort Key
  133. Amazon DynamoDB Read Consistency, CAP Theorem and Eventual Consistency
  134. Amazon DynamoDB Read and Write Capacity Mode
  135. Amazon DynamoDB API References
  136. Amazon DynamoDB PartiQL - A SQL-Compatible Query Language for DynamoDB
  137. Accessing DynamoDB with Different Ways
  138. Amazon DynamoDB - Walkthrough with AWS Management Console
  139. Introduction - Amazon DynamoDB Walkthrough with AWS Management Console
  140. Create our First Amazon DynamoDB Table with AWS Management Console
  141. Write an Item into Amazon DynamoDB Table with AWS Management Console
  142. Read Data - Scan Command - from Amazon DynamoDB Table with AWS Console
  143. Read Data - Query Command - from Amazon DynamoDB Table with AWS Console
  144. Update Data from Amazon DynamoDB Table with AWS Management Console
  145. Create a Global Secondary Index on Amazon DynamoDB Table with AWS Console
  146. Query the Global Secondary Index on Amazon DynamoDB Table with AWS Console
  147. Query Data using PartiQL Editor from Amazon DynamoDB Table with AWS Console
  148. Clear Resources
  149. Amazon DynamoDB Walkthrough with AWS CLI
  150. Introduction - Amazon DynamoDB Walkthrough with AWS CLI
  151. Create DynamoDB Table with AWS CLI
  152. Write Data into DynamoDB Table with AWS CLI
  153. Read Data into DynamoDB Table with AWS CLI
  154. Update Data into DynamoDB Table with AWS CLI
  155. Query Data into DynamoDB Table with AWS CLI
  156. PartiQL CRUD Operations into DynamoDB Table with AWS CLI
  157. Clear Resources
  158. Hands-on Lab: Build RESTful Microservices with AWS Lambda, Api Gateway, DynamoDB
  159. Intoductuction - RESTful Microservices with AWS Lambda, Api Gateway and DynamoDb
  160. Create a DynamoDB Table
  161. Create a Lambda Function
  162. Create an API Gateway
  163. Test - RESTful Microservices with AWS Lambda, Api Gateway and DynamoDb
  164. AWS Console microservice-http-endpoint Lambda Blueprint - Api Gw + Lambda + DB
  165. Resource Cleanup
  166. NodeJS Basics - Recap NodeJS
  167. Why we need to know NodeJS Basics ? Skip or Continue ?
  168. NodeJS Basics and Installment
  169. Running Node Command
  170. Run NodeJS Functions
  171. Passing Arguments to NodeJS Functions
  172. NodeJS Modules
  173. NPM - Node Package Manager and Use npm packages into NodeJS
  174. AWS SDK for JavaScript - Developer Guide for SDK Version 3
  175. What is AWS SDK ?
  176. AWS SDK for JavaScript Version 3 and using SDK with Node.js
  177. What's new in AWS SDK for JavaScript Version 3 and Cold Start Benefit
  178. Important - ECMAScript 6 (ES6) Requirements
  179. Using Node.js ES modules and top-level await in AWS Lambda
  180. Amazon DynamoDB - Developing with AWS SDK- Programmatic Access w/ Serverless API
  181. Introduction - Amazon DynamoDB SDK Examples
  182. Understanding DynamoDb Interactions - Working with Items and Attributes
  183. Create NodeJS Project with DynamoDB SDK Packages
  184. Create DynamoDBClient NodeJS Module For Connecting DynamoDB
  185. Creating a DynamoDB Table
  186. Listing DynamoDB Tables
  187. Describing DynamoDB Table
  188. Deleting DynamoDB Tables
  189. Reading and writing a Single item in DynamoDB Table
  190. Writing an Item into DynamoDB Table
  191. Update an Item into DynamoDB Table
  192. Getting an Item into DynamoDB Table
  193. Deleting an Item into DynamoDB Table
  194. Writing Items in Batch into DynamoDB Table
  195. Reading Items in Batch into DynamoDB Table
  196. Querying and Scanning a DynamoDB table
  197. Querying a DynamoDB Table
  198. Scanning a DynamoDB table
  199. PartiQL CRUD Operations into DynamoDB Table with AWS SDK
  200. Add an item into DynamoDB Table using PartiQL
AWS Lambda and the Serverless Framework - Hands On Learning!

Develop and Deploy AWS Lambda Functions with Serverless, Learn Lambda Real World Integrations with Amazon Web Services

thumbnail
Ratings
4.51
Subscribers
60,988
Subscribers last month
(August 2023)
467
Level
beginner
Video Duration
10 hours 28 minutes
Created
Jun 4th, 2017
Last updated
Jul 1st, 2022
Price
$94.99

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. Next Steps
  107. Bonus
The Complete Guide to Build Serverless Applications on AWS

Learn to Build Serverless Applications with AWS Lambda, DynamoDB, API Gateway, AppSync, SQS, S3, many more AWS Services!

thumbnail
Ratings
4.49
Subscribers
4,894
Subscribers last month
(August 2023)
234
Level
all
Video Duration
26 hours 32 minutes
Created
Apr 27th, 2022
Last updated
Jun 10th, 2023
Price
$79.99

Welcome to this course! In this course, you’ll learn serverless fundamentals and gradually dive deep into production-ready serverless application implementations.

By following this course, you’ll get hands-on experience with serverless services like AWS Lambda, Amazon API Gateway, AWS AppSync, Amazon DynamoDB, Amazon Cognito, SQS, SNS, IAM, and many more services...


What is Covered in the Course?

1. Serverless Fundamentals

This section includes lessons to get you up-to-speed with commonly used serverless services on AWS such as AWS Lambda, Amazon API Gateway,  Amazon DynamoDB, IAM and etc... If you are new to AWS, this is a must-to-watch section and it will help you easily follow along with the rest of the sections in the course.

2. Serverless REST API Development

In the next couple of sections, you'll learn to build a Serverless REST API that handles CRUD operations from scratch. I will cover the following topics:

  • Use the serverless framework to provision and deploy Lambda functions, API Gateway, and DynamoDB.

  • Implement Access Controls to your REST APIs with Lambda Authorizers and Cognito User Pool Authorizers.

  • Use the principle of least privilege to provide minimum permission to the Lambda functions that talk to the DynamoDB tables.

  • How to secure your API with Web Application Firewall (AWS WAF)

  • How to write acceptance tests for your API

  • How to deploy your API for multiple environments (Dev/Test/Staging/Prod)

  • Many more...

3. Serverless GraphQL API Development

Next, you'll learn how to build GraphQL API with AWS AppSync for an online book store application. AWS AppSync is a managed GraphQL service that'll help you build powerful GraphQL APIs easily.  I will cover the following topics:

  • Design the GraphQL schema with Queries, Mutations, and Subscriptions

  • Create AppSync resolvers to communicate with AWS services such as Amazon DynamoDB

  • Implement role-based access control with Cognito User Pool for the AppSync API

  • Implement Guest User Access to the AppSync API

  • Many more...

4. Serverless Use Cases

When building serverless applications, we come across many real-world challenges. So we are going to cover several real-world use-cases and how to build solutions with serverless architectures. I will cover the following topics:

  • How to deal with large payloads

  • How to improve user experience with asynchronous & event-driven architectures

  • How to implement real-time monitoring and troubleshooting architectures

  • Many more...

This course will be constantly updated with new sections with more content to keep up with the innovations that taking place in AWS serverless world.


Happy Learning!

Manoj.

  1. The Mindset: Thinking Serverless
  2. Introduction
  3. Serverless Mindset (Cont.)
  4. Serverless System Design: A Real World Use Case
  5. System Introduction
  6. Functional & Non-Functional Requirements
  7. Frontend Architecture Design
  8. Use of DynamoDB
  9. Evaluating the User Registration Architecture
  10. Decoupling the Architecture with SQS an EventBridge
  11. Using EventBridge for Extending the Architecture
  12. Rate Controlling with Serverless Queue
  13. Managing Serverless Workflows with State Machines
  14. Optimizing with Circuit Breaker Pattern
  15. Achieving Idempotency in Serverless Architectures
  16. Providing Temporary Access to Protected Resources
  17. Let's Begin: Serverless Fundamentals
  18. Section overview
  19. Introduction to AWS Lambda
  20. AWS Lambda demo
  21. Introduction to Amazon API Gateway
  22. Introduction to Amazon DynamoDB
  23. Learn more about Amazon DynamoDB
  24. Introduction to Identity and Access Management (IAM)
  25. Learn more about AWS IAM
  26. Introduction to CloudWatch
  27. CloudWatch Demo
  28. Introduction to GraphQL and AWS AppSync
  29. Introduction to Cognito User Pool
  30. Building REST APIs: The Most Common Serverless Use Case
  31. Application overview
  32. Architecture overview
  33. Installing Serverless CLI
  34. Creating a Serverless Service
  35. Building the first Lambda function and connect with API Gateway
  36. Creating other CRUD endpoints
  37. Viewing the resources on AWS console
  38. Creating a DynamoDB table with CloudFromation
  39. Implementing CreateNote Lambda Function
  40. Using serverless-iam-role-per-function plugin
  41. Implementing UpdateNote Lambda function
  42. Implementing DeleteNote Lambda Function
  43. Implementing GetNotes Lambda function
  44. Using callbackWaitsForEmptyEventLoop
  45. Reusing Connections with HTTP Keep-Alive
  46. Solution to DynamoDB Timeout Issue
  47. Section Summary
  48. Migrating to AWS SDK V3 and Serverless V3
  49. Access Control: Learn About Authentication and Authorization
  50. Using API Key
  51. When should we use API Key?
  52. API Gateway Usage Plan Demo
  53. Introduction to Lambda Authorizer
  54. Implementing the Lambda Authorizer
  55. Lambda Authorizer Logs
  56. Introduction to Cognito User Pool
  57. Creating a User Pool using AWS Console
  58. Using aws-jwt-verifier in the Lambda Authorizer
  59. Cognito User Pool Authorizer
  60. An important note about Cognito User Pool Authorizer
  61. Creating the Cognito User Pool with CloudFormation (IaC)
  62. Using Environment Variables
  63. Introduction to SSM Parameter Store
  64. Creating the Parameter with CloudFormation
  65. Fixing the deployment issue
  66. Updating configurations and testing the API
  67. Deployment: Setting up Multiple Environments
  68. Section overview
  69. Deleting the current stack
  70. Multi-environment configurations
  71. Fixing the deployment error
  72. Creating a new DEMO environment
  73. Testing the environment
  74. CI & CD: Continuously Deliver with AWS CodePipeline
  75. Section overview
  76. A Word about CI and CD
  77. Creating a CodePipeline
  78. Creating the buildspec.yml file for the Build Stage
  79. Testing the Build Stage of the Pipeline
  80. Where are the Build Artifacts?
  81. Configuring the Deploy Stage
  82. Troubleshooting the Deploy Stage
  83. Implementing Manual Approval Stage
  84. Github Actions: The Easiest Way to Deploy Serverless Applications
  85. Section Overview
  86. Introduction
  87. GitHub Action Overview
  88. Setting-up a Workflow
  89. Building the Serverless Workflow
  90. Github Actions Environment Variables
  91. Testing the Production Deployment Workflow
  92. Testing: Focusing on User Acceptance Testing (UAT) with JEST
  93. Section overview
  94. Creating Test Helper Files
  95. Using Cognito Admin API
  96. Enabling ADMIN_AUTH_FLOW in Cognito
  97. Testing Creating Notes
  98. Adding Update & Delete Note Tests
  99. Lambda Authorizer Caching Issue [A Gotcha]
  100. The Best Solution to the Caching Issue
  101. TypeScript: Learn to use TypeScript with the Serverless Framework
  102. Introduction
  103. Installing Serverless TypeScript Plugin
  104. Updating Lambda Hanlder Code
  105. Adding Types for Lambda Functions
  106. Adding Types to Lambda Authorizer Function
  107. Deploying the Service
  108. Lambda Function URLs & Lambda Response Streaming
  109. Introduction to Lambda Function URLs
  110. Deploying Function URLs with Serverless Framework
  111. Lambda Response Streaming Scenario
  112. EventBridge & SQS: Building Event-Driven Architectures
  113. Introduction
  114. Asynchronous Communication Overview
  115. AWS EventBridge Overview
  116. EventBridge Console Walkthrough
  117. Using API Gateway Service Proxy Integration with EventBridge
  118. Creating an EventBus with Serverless Framework
  119. Adding Events to EventBridge EventBus
  120. Setting up a SQS as a Target to EventBridge
  121. 6 Things to Remember about SQS
  122. Batch Processing Messages with AWS Lambda
  123. Introduction to Dead Letter Queues (DLQ)
  124. Implementing a DLQ with the SQS
  125. API Gateway Service Proxy Introduction
  126. Implement API Gateway and EventBridge Service Proxy
  127. AWS Step Functions: Let's Manage Your Workflows
  128. Section Overview
  129. Step Function Overview (Pros & Cons)
  130. Introduction to Step Functions
  131. Understanding Frequently used States
  132. Callback Pattern in Step Functions
  133. Store Checkout Process in Detail
  134. Installing Serverless Step Functions Plugin
  135. Creating CheckInventory Task State
  136. Testing the State Machine from AWS Console
  137. Check Inventory Implementation with Error Handling
  138. The use of ResultPath in States
  139. Redeem Points with Choice State
  140. Testing the State Machine
  141. Implementing Step Functions Callback pattern with SQS
  142. Email Order Details with SNS
  143. AWS Step Function Patterns
  144. Improving Security: Starting with AWS Web Application Firewall
  145. Section overview
  146. Benefits of CloudFront in Security & Performance
  147. CloudFront and Caching Demo
  148. Using CloudFormation to Create the CloudFront
  149. Benefits of Web Application Firewall (AWS WAF)
  150. Creating a Web ACL for CloudFront
  151. Testing the WAF Web ACL
  152. Web ACL Graphs and Sampled Requests
  153. Adding Rate Based Rules to Mitigate DDoS Attacks
  154. Creating Custom WAF Rules
  155. Building GraphQL APIs: Learn AWS AppSync and Amplify Framework
  156. Overview
  157. Agenda
  158. Introduction to GraphQL
  159. Introduction to AWS AppSync
  160. Setting up the dev environment
  161. Initializing an Amplify project
  162. Provisioning backend resources with Amplify CLI
  163. Creating the backend schema
  164. About the amplify @model directive
  165. Adding Entity Relationships with @connection directive
  166. Adding Authorization Rules with @rules directive
  167. Testing the GraphQL API
  168. AWS AppSync and Serverless Framework
  169. Overview
  170. Introduction
  171. Creating GraphQL API Resources
  172. Exploring the Resources on AWS Console
  173. Designing the GraphQL Schema
  174. Introduction to Serverless AppSync Plugin
  175. Implementing getBookById Query
  176. Implement createBook Mutation
  177. Testing the Mutation & Query
  178. Connecting a React App with the AppSync API
  179. Calling AppSync API from React App
  180. AWS AppSync Authorization Methods
  181. Adding AWS_IAM authentication type to the AppSync Schema
  182. Creating an Cognito Identity Pool with CloudFormation
  183. Testing Guest User Access
  184. Pagination with AWS AppSync and DynamoDB
  185. Creating an AppSync Subscription for Real-time Communication
  186. Connecting AppSync Subscription with a React Frontend
  187. A Complete Project: Building an Online Bookstore with Amplify and AppSync
  188. Project Overview
  189. Agenda
  190. Final demo
  191. Project Architecture
  192. Setting up the project
  193. Creating an Amplify Project
  194. Creating Cognito User Pool and S3 buckets
  195. Creating Lambda Functions
  196. Building GraphQL Schema with Amplify Directives
  197. Creating Lambda Pipeline Resolvers
  198. Deploying Resources to AWS with Amplify Push Command
  199. Installing Lambda Dependencies
  200. Testing the React App with the Backend
Master AWS Lambda: Go Serverless with AWS

AWS Lambda for Beginners - Learn AWS Lambda, Azure Functions, SAM & Serverless Framework

thumbnail
Ratings
4.66
Subscribers
5,402
Subscribers last month
(August 2023)
-
Level
all
Video Duration
12 hours 14 minutes
Created
Sep 19th, 2020
Last updated
May 4th, 2023
Price
$89.99

LEARN THE FUNDAMENTALS OF SERVERLESS WITH AWS LAMBDA IN LESS THAN 12 HOURS!

BONUS: AZURE FUNCTIONS & More...


7 Things YOU need to know about this SERVERLESS Course

#1: HIGHEST RATED Serverless Course (August 2021)

#2: Learn SERVERLESS in AWS: REST API with AWS Lambda and API Gateway

#3: Learn SERVERLESS in AZURE: Azure Functions and Azure API Management

#4: AUTOMATE SERVERLESS in AWS: Serverless Framework and Serverless Application Model

#5: DEPLOY FULL STACK SERVERLESS APP in AWS and Azure

#6: IMPLEMENT Advanced REST API Features - validation, rate limiting, multiple environments etc

#7: EXPLORE OTHER AWS and AZURE services: Amazon S3, Amazon Cognito and Azure AD B2C


WHAT STUDENTS ARE SAYING

5 STARS - Well explained concepts with hands-on which helps even if you do not have any prior knowledge on these topics .

5 STARS - For a total beginner, this was a very useful course. Compared to another course on the same subject I did in parallel, this course went into depth as well as were not afraid of some repetition. I got not only comfortable with working with serverless, but cloud resources in general. Thanks for clear explanations paired with solid material.

5 STARS - Awesome course, thanks Ranga again for the fantastic content you present!

5 STARS - It's a good match for my interests and where i want to be in future - i.e. knee deep in coding/dev ops/cloud!!!!!


Do you have ZERO experience with Serverless, AWS, and Azure?

Do you want to build an amazing full-stack Serverless application in AWS and Azure with an easy-to-learn, step-by-step approach?

Do you want to learn AWS Lambda, Azure Functions, Amazon API Gateway, Azure API Management, Amazon Cognito, and Azure AD B2C?

Are you ready to learn Serverless and take the next step in your programming career?

Do you want to join 500,000+ learners having Amazing Learning Experiences with in28Minutes?

Look No Further!


COURSE OVERVIEW

Building Serverless Applications in AWS and Azure is a lot of fun.

We will start with understanding the fundamentals of building Serverless REST API in AWS with Lambda Functions and API Gateway. You will learn to monitor, version, and configure your AWS Lambda Functions. You will learn to build your REST API using API Gateway. We will explore the two important types of API Gateway in-depth - HTTP API and REST API. You will learn to implement validation, rate limiting, and multiple stages with AWS API Gateway.

After that, we switch our focus to deploying a full-stack todo management application with a Serverless approach in AWS. We will use Amazon DynamoDB to store our todos. We will build our REST API using Lambda Functions and API Gateway. We will deploy our Front end application as a static website to Amazon S3. We will use Amazon Cognito to manage and authenticate our users.

Building Lambda Functions and configuring API Gateway manually is a pain. We will learn to automate building Serverless applications in AWS with the Serverless Framework and Serverless Application Model. We will build and deploy a complete Serverless REST API (AWS Lambda + API Gateway + Amazon DynamoDB) with Serverless Framework and Serverless Application Model.

This course would be a perfect first step as an introduction to Serverless in AWS and Azure.

You will be using AWS Lambda (Serverless Functions), API Gateway (API Management), Amazon DynamoDB (Database), Amazon S3 (to deploy frontend application), Amazon Cognito (Authentication and Authorization), Azure Functions (Serverless Functions), Azure API Management and Azure AD B2C (Authentication). We will be using Visual Studio Code as the IDE.

Start Learning Now. Hit the Enroll Button!

  1. Introduction
  2. Course Overview - Go Serverless with AWS Lambda and Azure Functions
  3. Github Repo - Go Serverless with AWS Lambda and Azure Functions
  4. Getting Started with Cloud and AWS
  5. Step 01 - Introduction to Cloud and AWS
  6. Step 02 - Creating an AWS Root Account
  7. Step 03 - Creating an IAM User For Your AWS Account
  8. Getting Started with Serverless and AWS Lambda
  9. Step 01 - What is Serverless?
  10. Step 02 - Getting started with AWS Lambda
  11. Step 03 - Creating Your First Serverless Function with AWS Lambda
  12. Step 04 - Understanding Your First Serverless Function - AWS Lambda Event and Re
  13. Step 05 - Playing with Your First Serverless Function - AWS Lambda Context
  14. Step 06 - Playing with Your First Serverless Function - AWS Lambda Basic Setting
  15. Step 07 - Monitoring your AWS Lambda Serverless Functions - CloudWatch and XRay
  16. Step 08 - Versioning your AWS Lambda Serverless Functions - Versions and Alias
  17. Step 09 - Understanding AWS Lambda Function Concurrency and Execution Context
  18. Playing with AWS API Gateway and Lambda Functions - REST API and HTTP API
  19. Step 01 - Getting started with AWS API Gateway
  20. CODE BACKUP FILE : For Reference
  21. Step 02 - Getting started with AWS API Gateway - API Types - HTTP, REST and WebS
  22. Step 03 - Creating Your First AWS API Gateway - REST API
  23. Step 04 - Understanding the Basics of Handling Request with AWS REST API Gateway
  24. Step 05 - Playing with AWS REST API Gateway - Customizing Mock Response and Head
  25. Step 06 - Integrating AWS REST API Gateway with Lambda Integration
  26. Step 07 - Playing with API Gateway - Using Mapping Template to map Request Heade
  27. Step 08 - Playing with API Gateway - Creating POST Method
  28. Step 09 - Playing with API Gateway - Validation Request Body using Model Schema
  29. Step 10 - Playing with API Gateway - Customizing Response Headers and Validation
  30. Step 11 - Deploying API Gateways - Creating a new Stage
  31. Step 12 - Understanding AWS REST API Gateway Integrations - Custom vs Proxy Inte
  32. Step 13 - Exploring REST API Gateway Lambda Proxy Integration
  33. Step 14 - Implementing Rate Limiting and API Keys using AWS API Gateway
  34. Step 15 - Exploring AWS API Gateway Stages
  35. Step 16 - Getting Started with AWS API Gateway - HTTP API
  36. Step 17 - Creating HTTP API - AWS API Gateway
  37. Step 18 - Exploring HTTP API - AWS API Gateway
  38. Step 19 - Exploring HTTP API - AWS API Gateway Further
  39. Do you want to help us?
  40. Monitor Billing on AWS - Best Practices
  41. Step 01 - Its Your Responsibility to Monitor Billing on the Cloud - 5 Recommenda
  42. Step 02 - Monitor AWS Billing Setting Billing Alerts
  43. Building REST API with AWS Lambda Functions and API Gateway REST API
  44. Step 01 - Getting started with building REST API for Todo Management Full Stack
  45. CODE BACKUP FILE : For Reference
  46. Step 02 - Getting Started with Amazon DynamoDB
  47. Step 03 - Understanding Amazon DynamoDB Tables
  48. Example Todo to Insert into DynamoDB in Next Step
  49. Step 04 - Creating Todo Table in Amazon DynamoDB
  50. Step 05 - Creating AWS Lambda Function and API Gateway for Get Todo API
  51. Step 06 - Connecting getTodo Lambda Function with DynamoDB
  52. Step 07 - Finalizing get todo REST API - Permissions and Testing
  53. Step 08 - Understanding AWS Lambda Function Handlers - async vs non async
  54. Step 09 - Creating List Todos Lambda Function
  55. Step 10 - Connecting List Todos Lambda Function with API Gateway
  56. Links for Next Lecture
  57. Step 11 - Getting Started with Full Stack Application - Angular Frontend
  58. Step 12 - Integrating Angular Frontend with Serverless REST API - CORS
  59. Step 13 - Implementing Update Todo API with Lamdba and API Gateway
  60. Step 13 - ZZ - COURSE UPDATE - Use new role for every lambda function
  61. Step 14 - Creating AWS Lambda Function for Create Todo
  62. Step 15 - Integrating Create Todo Lambda with API Gateway and Frontend
  63. Step 16 - Implementing Delete Todo API with Lamdba and API Gateway
  64. Step 17 - Getting Started with Amazon Cognito for Authentication and Authorizati
  65. Step 18 - Understanding Cognito User Pools and Identity Pools
  66. Step 19 - Creating Amazon Cognito User Pool for Todo Application
  67. Step 20 - Playing with Amazon Cognito - Configuring App Client and User Flow
  68. Step 21 - Playing with Amazon Cognito - Creating Pre Signup Trigger for Confirmi
  69. Step 22 - Creating Authorizer in API Gateway and enabling Authentication for RES
  70. Step 23 - Integrating Angular Frontend with Amazon Cognito User Pool
  71. Step 24 - Exploring integration of Angular Frontend with Cognito User Pool
  72. Creating Todo REST API with AWS Lambda Functions and HTTP API - API Gateway
  73. Step 01 - Creating HTTP API - API Gateway - Using Import
  74. Step 02 - Configuring HTTP API - API Gateway - CORS and Lambda Integrations
  75. Step 03 - Creating JWT Authorizer and Enabling Authentication for REST API
  76. Building AWS Serverless Applications with AWS SAM - Serverless Application Model
  77. Step 01 - Getting Started with AWS SAM - Serverless Application Model
  78. Step 02 - Getting Started with AWS SAM - Installing Required Tools
  79. Step 03 - Creating and Deploying a Serverless Application with AWS SAM
  80. Step 04 - Exploring AWS SAM Template
  81. CODE BACKUP FILE : For Reference
  82. Step 05 - Exploring AWS resources created by SAM - Lambda, API Gateway and Cloud
  83. Step 06 - Configuring HTTP API Gateway and Exploring Change Sets
  84. Step 07 - Creating List Todo Function using SAM - Automating DynamoDB permission
  85. Step 08 - Configuring SAM Globals - AWS Lambda Environment Variables
  86. Step 09 - Configuring JWT Authorizer for HTTP API Gateway in AWS SAM
  87. Step 10 - Creating Get Todo REST API using AWS SAM
  88. Step 11 - Creating Update Todo REST API using AWS SAM
  89. Step 12 - Creating Delete Todo and Create Todo REST API using AWS SAM
  90. Step 13 - Creating DynamoDB Table using AWS SAM
  91. Step 14 - Learning more about Serverless Application Model - References
  92. Building AWS Serverless Applications & Lambda Function with Serverless Framework
  93. Step 01 - Getting Started with Serverless Framework
  94. Step 02 - Getting Ready for Serverless Framework - Installation and Configuratio
  95. Step 03 - Creating an AWS Serverless Project using Serverless Framework
  96. CODE BACKUP FILE : For Reference
  97. Step 04 - Connecting AWS Lambda Function with API Gateway - Serverless Framework
  98. Step 05 - Configuring HTTP API - API Gateway with Serverless Framework
  99. Step 06 - Creating List Todos REST API with Serverless Framework
  100. Step 07 - Creating DynamoDB Table using Serverless Framework
  101. Step 08 - Configuring JWT Authorizer using Serverless Framework
  102. Step 09 - Creating Todo REST API using Serverless Framework
  103. Step 09 - Learning more about Serverless Framework - References
  104. Appendix - More Serverless with AWS
  105. Step 01 - Deploying Angular Frontend Application as Static Website to S3
  106. Step 02 - Using username from Cognito JWT Claims
  107. Step 03 - Getting Started with SQS
  108. Step 04 - Sending and Receiving a Messaging using SQS - Best Case
  109. Step 05 - Creating an Amazon SQS Queue and Playing with Messages
  110. Step 06 - Getting Started with Simple Notification Service - SNS
  111. Step 07 - Creating an SNS Topic and Registering a Lambda to Subscribe
  112. Step 08 - Registering an SQS Queue as a subscriber to an SNS Topic
  113. Getting Started with Serverless Applications in Azure with Azure Functions
  114. Step 00 - Getting Started - Serverless with Azure
  115. Step 01 - Creating an Azure Account
  116. Step 02 - Exploring Cloud Best Practices - Minimize Costs
  117. Step 03 - Creating Your First Azure Serverless Function App
  118. Step 04 - Creating Your First Azure Serverless Function
  119. Step 05 - Playing with Azure Serverless Function - Req and Response
  120. Step 06 - Playing with Azure Serverless Function - Context and Bindings
  121. Building Azure Functions in Visual Studio Code
  122. Step 07 - Getting Ready for Building Azure Functions in Visual Studio Code
  123. Step 08 - Creating Your First Azure Serverless Function App from Visual Studio C
  124. CODE BACKUP FILE : For Reference
  125. Step 09 - Running Azure Serverless Function in Local
  126. Step 10 - Customizing response and bindings for List Todos Function
  127. Connecting Azure Functions to MongoDB - Azure Cosmos DB
  128. Step 11 - Creating Azure Cosmos DB Account
  129. Todos for inserting into MongoDB in Next Step
  130. Step 12 - Creating Cosmos DB Database and Collections
  131. Step 13 - Connecting listTodo Azure Function with MongoDB
  132. Step 14 - Creating Environment Variables for Database Configuration
  133. Step 15 - Creating Azure Function for List Todos REST API
  134. Connecting Angular Frontend to Azure Functions
  135. Step 16 - Connecting Angular Frontend to Azure Functions
  136. Step 17 - Creating Update Todo REST API Azure Function and Connect to Frontend
  137. Step 18 - Creating Delete Todo REST API Azure Function and Connect to Frontend
  138. Step 19 - Creating Create Todo REST API Azure Function and Connect to Frontend
  139. Deploying to Azure and Getting Started with Azure API Management
  140. Step 20 - Deploying Azure Function to Azure
  141. Step 21 - Configuring Environment Variables and CORS for Azure Function App Depl
  142. Step 22 - Creating Azure API Management to Manage Your REST API
  143. Step 23 - Connecting Azure API Management to APIs from Azure Functions App
  144. Step 24 - Connecting Frontend App to REST API through Azure API Management
  145. Step 25 - Deploying Frontend Application as Static Website in Azure
  146. Setting up Authentication with Azure Active Directory B2C
  147. Step 26 - Creating Azure Active Directory B2C Tenant
  148. Step 27 - Creating Azure Active Directory B2C App Registrations
  149. Step 28 - Creating Azure Active Directory B2C User Flow for Sign in and Sign up
  150. Step 29 - Creating a User for Azure Active Directory B2C
  151. Step 30 - Connecting Azure API Management with Azure Active Directory B2C
  152. Step 31 - Connecting Frontend Application with Azure AD authentication
  153. Appendix - Setting up Frontend Angular Application
  154. Links for Next Lecture
  155. Step 01 - Getting Started with Full Stack Application - Angular Frontend
  156. Before You Go
  157. Bonus Lecture

3. Top 3 Recommended YouTube Videos

Here are Outlecture's top 3 recommended YouTube videos, carefully selected for you.

Title View count View count last month
(August 2023)
Like count Publish date

Serverless Framework with AWS Lambda Crash Course

thumbnail

Channel: Laith Academy

93,923 3,186 1,893 Jun 9th, 2021

Serverless Framework with NodeJS

thumbnail

Channel: Piyush Garg

5,679 2,582 161 May 12th, 2023

Getting Started with Serverless Framework

thumbnail

Channel: Serverless

23,300 916 340 Mar 15th, 2022

YouTube has become a familiar platform for everyday use, where viewers can watch videos for free, although they may contain advertisements. Recently, there has been an increase in the availability of high-quality educational materials on this platform. It is an excellent option for those who want to learn without paying or simply obtaining a quick understanding of a topic.
We highly recommend utilizing YouTube as a valuable learning resource.

Recommended for

  • Wanting to learn without spending money
  • Wanting to quickly understand the overview of Serverless Framework

The details of each course are as follows:

Serverless Framework with AWS Lambda Crash Course

Laith Academy

View count
93,923
View count last month
(August 2023)
3,186
Like count
1,893
Publish date
Jun 9th, 2021
This crash course aims to teach you the concepts of serverless as well as build a serverless application with AWS Lambda.

Second Channel:
https://www.youtube.com/channel/UCfNFgrUzeDSb-W3L3nnjC5A

Download AWS CLI:
https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html

Timeline:
0:00 - Intro to Serverless
16:00 - IAM & AWS CLI
30:48 - Create a Serverless App with IaC
38:49 - Investigating the YAML File
52:30 - Creating Lambda Functions
1:25:13 - Middleware
Serverless Framework with NodeJS

Piyush Garg

View count
5,679
View count last month
(August 2023)
2,582
Like count
161
Publish date
May 12th, 2023
In this video, we dive into the powerful combination of a Serverless Framework and Node.js. If you're a developer looking to build scalable and efficient applications without the hassle of managing servers, this is the perfect tutorial for you.

Quick Links
► My Personal Website: https://piyushgarg.dev
► Courses Website: https://learn.piyushgarg.dev
► Full Stack Twitter Clone: https://learn.piyushgarg.dev/learn/twitter-clone?COUPON=EARLY_BIRD

Video Titles
- Exploring AWS Lambda: The Power of Serverless Computing
- Serverless vs. Monolith: Which Architecture Is Right for You?
- Serverless Made Easy with AWS Lambda
- Breaking Down the Pros and Cons of Serverless Computing

Hashtags
#nodejs #serverless #serverside #backenddeveloper #softwareengineer #softwaredeveloper #aws #awslambda #amazonwebservices #cloudcomputing #devops #webdevelopment #fullstack
Getting Started with Serverless Framework

Serverless

View count
23,300
View count last month
(August 2023)
916
Like count
340
Publish date
Mar 15th, 2022
This Webinar is for developers who are looking for a point of entry with Serverless Framework.

What we'll cover:
- Quickly getting up and running with a deployed REST API
- What is Serverless Dashboard?
- What you'll need to get deployed.

By the end, you'll have two end points that are production ready and are fully redundant in AWS across three Availability Zones and fully load balanced. Ready to receive the traffic you want to throw at it without the associated bill of infrastructure sitting around waiting to be used.

Featuring:
Gareth McCumskey - Developer Advocate at Serverless

5. Wrap-up

We introduced recommended courses for Serverless Framework. If you are interested in learning other related courses, please refer to the following.

Jenkins
Istio Service Mesh
Amazon EKS
Jenkins
Istio Service Mesh
Amazon EKS

If you want to further explore and learn after taking one of the courses we introduced today, we recommend visiting the official website or community site.

If you want to stay up-to-date on the latest information, we suggest following the official Twitter account.

Furthermore, We highly recommend utilizing General AI such as ChatGPT as a study aid. This can enable more effective learning, so please give it a try.

We hope you found our website and article helpful. Thank you for visiting.

Back to list
Home About Share
Home
About
Privacy policy
Disclaimer
Contact
Official
© 2023 outlecture.com All Rights Reserved.