AWS Serverless APIs & Apps - A Complete Introduction
4.7 (669 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
4,989 students enrolled
Wishlisted Wishlist

Please confirm that you want to add AWS Serverless APIs & Apps - A Complete Introduction to your Wishlist.

Add to Wishlist

AWS Serverless APIs & Apps - A Complete Introduction

Get into serverless computing with API Gateway, AWS Lambda and other Amazon Web Services! Zero server config APIs & SPAs
Best Seller
4.7 (669 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
4,989 students enrolled
Last updated 9/2017
English
English [Auto-generated]
Current price: $12 Original price: $145 Discount: 92% off
3 days left at this price!
30-Day Money-Back Guarantee
Includes:
  • 7.5 hours on-demand video
  • 27 Articles
  • 51 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Assignments
  • Certificate of Completion

Training 5 or more people?

Get your team access to Udemy's top 2,000 courses anytime, anywhere.

Try Udemy for Business
What Will I Learn?
  • Build, secure and run APIs without managing any servers using AWS API Gateway and Lambda
  • Host SPAs without managing any servers
  • Add user authentication to serverless applications
  • Run code on-demand in the cloud
View Curriculum
Requirements
  • You should have a basic understanding about what AWS (Amazon Web Services) is or bring the willingness to learn more about them alongside taking this course
  • You will need a credit card to create an AWS account
  • You should have a basic understanding about what APIs and SPAs (Single-Page-Applications) are and what role they play in modern web development
  • You don't need to be anything close to an AWS expert!
  • You don't need to have advanced API/ SPA knowledge!
Description

Serverless computing will shape the future of web development since it allows you to get rid of many issues "traditional" web hosting poses. Now's the time to dive into this exciting new technology!

Unlike in traditional web hosting, where you spin up servers, configure them and then deploy your code, in serverless applications, you don't manage any servers! Instead, you only provide your code and define when it should get executed. Done!

Without managing any servers, you typically pay way less (since you got no overhead capacity), can react much better to incoming traffic spikes and don't have to worry about server security!

For these very reasons, it's no wonder that serverless computing is on the rise, with more and more companies adopting it! Learn it now to gain an edge and either use it for your own projects or apply for high-paid jobs!

What does this course offer then?

This course will introduce you to serverless computing and then quickly dive into how to build serverless apps with Amazon Web Services (AWS).

Specifically, you will learn:

  • how you can build a REST API without worrying about servers, using AWS API Gateway
  • to set up your on-demand code via AWS Lambda 
  • how to execute that Lambda code whenever incoming requests reach your defined REST endpoints
  • how you can store data in a database - naturally without managing any database servers!

We won't stop there though! Instead, you'll then dive even deeper into serverless computing and learn:

  • how you can add user authentication to your existing frontend apps and how you can then also protect your REST API against unauthenticated access with ease!
  • how you can easily integrate a complete user sign up & sign in flow (including user confirmation) into ANY app (web app, iOS or Android app!) with AWS Cognito
  • how to deploy your web app in a serverless manner
  • how to speed up the delivery of your static web app assets
  • how to secure your serverless app
  • what else you can build with the services covered in this course and which other services might be interesting to you
  • where to dive deeper regarding advanced development workflows 
  • and much more!

Is this course for you?

Now that you know what this course offers, is it the right choice for you? Which skills should you bring?

This course is absolutely the right choice for you if you're interested in providing great web applications without worrying about the provisioning of servers.

It's also the right choice if you already got experience as a system administrator but are interested in keeping up with the latest developments and the many new possibilities serverless computing offers.

You will need some basic AWS knowledge, or the willingness to dive deeper into AWS alongside taking this course. Additionally, a credit card is required for signing up to AWS.

Finally, you should be familiar with APIs and SPAs (Single-Page-Applications) and which role they play in today's web development environment. You don't need to know how to create them though.

I'd be very happy to welcome you on board! 

Who is the target audience?
  • Anyone who's interested in focusing on the core business logic instead of the infrastructure needed to run an API and/ or SPA
  • Anyone who wants to use modern techniques to create highly scalable and extremely cost-efficient web apps
  • Anyone who works with APIs and/ or SPAs on a regular basis and wants to learn how to create flexible and cost-effective web apps
  • Every developer who loves the "Dev" in "DevOps" but would be happy to make the "Ops" part easier
Compare to Other Amazon AWS Courses
Curriculum For This Course
138 Lectures
07:48:22
+
Getting Started
10 Lectures 27:41

Let me introduce you to this course, its goals and what you're going to learn!

Preview 02:44

We learned what Serverless Computing is - but what's AWS?

Preview 01:51


This course is about serverless computing. But what does that actually mean? This lecture takes a closer look.

Preview 05:36

Let's clarify one important question right at the start!

Preview 00:40

With the theory out of the way, let's build our first serverless API. For that, we'll need an account though - time to create one!

Preview 08:31

This course covers AWS - are there no alternatives? Yes there are, this lecture outlines why AWS is chosen amongst them.

Preview 01:01

This lecture will walk you through the structure of the course and show what you can expect from it.

Preview 03:22

Obviously, you want to get the most out of this course. In this lecture, I'll share some extremely important guidelines on how to achieve that.

Preview 02:21

In this course, I provide a couple of files for download (e.g. lambda code files). Learn how to use these files in this lecture.

How to use the File Downloads
00:39
+
The Core Serverless Services
4 Lectures 09:33

Let me introduce you to this course module and what we're going to cover in it.

Module Introduction
00:43

Which AWS services are actually involved when creating a serverless app? This lecture dives into that question.

An Overview over the Core Serverless Services
05:31

You got the bigger picture and we'll dive into the services in detail throughout the course. In case you don't want to wait that long, you can check out this lecture though.

More Info about the Core Services
00:29

Theory is nice but it's extremely important to also see how the things come together in practice. That's why we'll build a complete project in this course. Learn more about it in this lecture.

The Course Project
02:50
+
Creating an API with API Gateway & AWS Lambda
37 Lectures 01:59:55

Let me introduce you to this course module and its content.

Module Introduction
00:55

Let's dive into the first service we'll cover in this course: AWS API Gateway. What is it and which roles does it play in a serverless app?

What is API Gateway?
02:17

We're going to dive into API Gateway, no worries. Still, it's never too early to share some useful links!

API Gateway: Useful Resources & Links
00:27

This lecture teaches you how to access the API Gateway console, the main tool we're going to work with in this course.

Accessing the API Gateway Console
01:03

Let's dive into API Gateway and take a closer look at its general features in this lecture!

General API Gateway Features
04:46

AWS by default doesn't grant any service any permissions. This is news to you? Have a look at this article then!

Understanding AWS Permissions (IAM)
00:18

After having a look at the general API features and options, let's now examine what we can configure for the individual APIs we create.

API-specific Features & Options
04:50

Each request which reaches API Gateway follows a certain cycle. Learn more about this cycle in this lecture.

Introducing the Request-Response Cycle
04:38

We got started with the Request-Response-Cycle in the last lecture, let's now dive deeper into it!

Understanding the Request-Response Cycle
06:12

Enough about the theory, it's time to create our first API. Learn how that works in this lecture.

Creating a New API
03:19

Having an API is nice but we also need resources (paths). This lecture shows how you can quickly create and configure such resources.

Creating a Resource (= URL Path)
03:15

When creating resources, we also have to keep CORS in mind, otherwise our frontend (web) apps won't be able to connect. Learn more about this matter in this lecture.

Handling CORS and the OPTIONS Preflight Request
04:11

With a resource created and CORS configured, it's time to handle Http methods. Learn how to register a method handler in this lecture.

Creating a (HTTP) Method
04:11

We finished our first steps in API Gateway. Thus far, we only mock data - time to change that and create our first lambda function!

What is AWS Lambda?
02:45

Just as with API Gateway, here's a little collection of helpful links in case you want to dive into more details or plan on playing around with Lambda on your own.

AWS Lambda: Useful Resources & Links
00:23

Make sure to read this lecture to understand how to create a blank Lambda function.

Must-Read: Minor Change to Lambda Interface
00:07

Now that we learned what Lambda actually is, let's dive into creating our first function in this lecture!

Creating a Lambda Function
10:05

We created a basic Lambda function but what, if you don't want to use the In-line code editor? You can simply upload a ZIP file!

Lambda Pricing & Uploading Code
00:58

We got a Lambda function and we got API endpoints. Time to connect both!

Connecting Lambda Functions to API Gateway Endpoints
01:27

Let's few our progress by accessing our API from the web. We'll also have another look at CORS for that.

Accessing the API from the Web & Fixing CORS Issues
07:24

Time to practice the basics of API Gateway and Lambda we learned thus far. You'll practice how to create an API with API endpoints (resources + methods) and how to mix Lambda into that.
Time to Practice - API Gateway + Lambda Basics
1 question

We got a working Lambda function - but what is this event object actually all about?

Understanding "event" in Lambda Functions
01:59

This lecture explores an alternative way of getting your requests to lambda: Directly forwarding them.

Forwarding Requests with "Proxy Integration"
03:52

How can we find out what's happening inside our function? By checking its logs! Learn how to do this in this lecture.

Accessing Lambda Logs
02:50

We learned how we can forward requests to Lambda. There's a better way of getting data into Lambda though. Learn more about that way in this lecture.

Getting Started with Body Mapping Templates
04:44

We learned about Body Mapping Templates. This lectures takes a closer look at how we actually extract request data with them.

Extracting Request Data with Body Mapping Templates
04:08

We took a closer look at Body Mapping templates. What's the core idea behind them?

What's the Idea behind Body Mappings?
02:09

Body Mapping Templates can be confusing but in the end, you often can stick to very simple ones. Let's take a closer look in this article.


Understanding Body Mapping Templates
01:07

We're not limited to mapping request data - we can also map the response as this lecture shows.

Mapping Response Data
02:41

With mapping templates covered, let's turn to "Models". What are these about? This lecture sheds some light on them.

Using Models & Validating Requests
03:14

We use JSON Schema Language to create a model schema in API Gateway. What's this language all about? Learn more in this article.

Understanding JSON Schemas
00:13

Models can be combined with mapping templates. This lecture explores how that works.

Models & Mappings
06:42

We learned quite a lot about Body Mapping Templates and Models. Time to put the things you learned into practice and use both features on your own!
Time to Practice - Models and Mappings
1 question

Time to take a quick break and plan the next steps.

Next Steps
01:24

Let's get back to adding resources and methods - time to add a DELETE method to our API!

Adding a DELETE Method Endpoint to the API
02:24

So far, we only considered static paths. You can also use dynamic ones though. This lecture shows how to get started with dynamic paths.

Using Path Parameters
08:42

If we're talking about Path Parameters, we also have to take a look at Query Parameters, don't we? This lectures dives into them.

What about Query Parameters?
00:17

The API is taking shape! Time to again test it from the web - with the correct data being passed to it.

Accessing the API from the Web - The Right Way
07:11

Let me wrap this module up and summarize it for you!

Wrap Up
02:43
+
Data Storage with DynamoDB
26 Lectures 01:26:32

Let me introduce you to this module.

Module Introduction
00:44

In this module, we're going to have a look at a database solution so that we're able to store some data. DynamoDB is going to be a good choice but what is it actually?

What is DynamoDB?
02:50

As always, don't miss your chance to dive into the official docs and learn more about DynamoDB.

AWS: DynamoDB Useful Resources & Links
00:19

We got a first impression of DynamoDB, this lecture will now dive deeper into that service and explain how data is organized in DynamoDB.

How DynamoDB Organizes Data
04:58

DynamoDB is a NoSQL database. Is that better or worse than SQL? What's the difference? Let's take a closer look in this lecture.

NoSQL vs SQL
02:51

DynamoDB is more fun if we use it together with other services - like Lambda! This lecture explores how the two services may work together.

Using DynamoDB with Lambda
00:52

Did you understand the basic concepts of DynamoDB? Do you know how to work with it? Let's find out!

DynamoDB Concepts
6 questions

Enough about the theory, let's see how that all works in practice. What better way to start than to create a new table?

Creating a Table in DynamoDB
02:40

DynamoDB uses Read & Write Capacity to charge you. What does that mean and how does that work? This lecture takes a closer look.

Understanding Read & Write Capacity
04:11

We got a table, we need items! This lecture will explore how you may add items to your DynamoDB table and how you can then scan them.

Creating and Scanning Items
02:16

DynamoDB uses multiple tables, we got that. But can you also use multiple databases?

What about multiple Databases?
01:20

Time to use our table from our Lambda function. This lecture teaches you how you may easily access DynamoDB from Lambda!

Accessing DynamoDB from Lambda
04:36

To understand the code we wrote in the last lecture, we also need to understand how Lambda works behind the scenes. This lecture explores that question.

Sidenote: How Lambda works behind the Scenes
01:42

We're already accessing DynamoDB from Lambda, time to make the next step and actually put an item there!

Putting Items into a DynamoDB Table from Lambda
06:14

In order to access DynamoDB from Lambda, we need to set the right permissions. And we can do better than we did thus far. Time to improve our permission settings.

Setting Permissions Right
02:18

Let's connect it all! Time to use the data from API Gateway in Lambda to finally create an item in DynamoDB fueled by that request data.

Using API Gateway (Request) Data for Item Creation
06:29

We put data into our DynamoDB, let's no work on the response Lambda returns. It's also time to see how that all works in a web app.

Mapping the Response & Web Testing
03:05

Adding data is nice but of course we also want to get that data back. Nothing easier than that! In this lecture, you'll learn how to scan your DynamoDB tables from Lambda.

Scanning Data in DynamoDB from Lambda
07:52

We already made sure that Lambda has the right permissions to access DynamoDB, but we can do far better and only provide the permissions Lambda actually needs. Time to do that!

Improving the IAM Permissions
04:30

We're scanning a DynamoDB table - the yielded data can now be restructured inside of Lambda. This lecture explores how we may do that.

Restructuring Fetched Data in Lambda
03:00

Scanning gives us ALL items. What if we only want one specific item? This lecture shows how that works.

Getting a Single Item from DynamoDB via Lambda
05:38

With all Lambda functions finished, it's now time to test it all from the web and see if it all works as expected. We'll also take a look at how the request needs to be sent.

Testing it from the Web & Passing Correct Data
01:37

Adding and getting data is nice but ultimately, we also want to be able to delete data. In this lecture, we'll prepare the permissions for that!

Preparing "Delete" Permissions
02:48

We improved the permissions but Lambda now is not able to create logs. If you do want it to do so, have a look at this article.

Giving Lambda Logging Rights
00:25

We added and retrieved data, now it's time to also delete data which is stored in DynamoDB.

Deleting Items in DynamoDB via Lambda
04:41

With all methods implemented, it's time to do some polishing and map some DynamoDB responses into "better" ones.

Mapping DynamoDB Responses
06:45

Let me wrap this module up and summarize what we learned.

Wrap Up
01:50
+
Authenticating Users with Cognito and API Gateway Authorizers
27 Lectures 01:46:18

Let me introduce you to this module.

Module Introduction
01:32

This lecture dives into how we may add authorization to API Gateway endpoints.

How to add Authorization to API Gateway
02:12

When we talk about protecting API Gateway Endpoints, we of course have to look at the features it offers us. Custom Authorizers are one of these features. Let's learn what these are about!

Understanding Custom Authorizers (API Gateway)
04:01

Now that we learned what custom authorizers are, it's time to dive into building our first custom authorizer function.

Creating a Custom Authorizer Function
10:12

When creating custom authorizers, there is a set of input data you will receive and a certain format of output data you should provide. Learn more about that in this lecture.

Custom Authorizers: Provided Input & Expected Output
00:49

Make sure to read this lecture to avoid errors when setting up the cognito authorizer.

MUST READ: New UI for setting up Custom Authorizers
00:07

We got our own authorizer function finished, with that, it's time to use it!

Using Custom Authorizers
05:50

It's great that we can control who's allowed to access our resources and who's not. But it would be even better if we could also retrieve the user who was granted access!

Retrieving Users from Custom Authorizers
06:09

With the basics about authorization explained, it's time to do the next step and see how we can also add a complete auth (sign up + sign in) flow to our existing apps. Learn how AWS Cognito helps you with that!

What is AWS Cognito?
02:27

We're using AWS Cognito in this module - time to share some useful links.

AWS Cognito: Useful Resources & Links
00:12

AWS Cognito actually consists of two parts. Learn more about these parts in this lecture!

Cognito User Pools and Federated Identities
01:31

With the basics about Cognito (and Cognito User Pools) set, let's now dive into creating our first User Pool!

Creating a Cognito User Pool
07:48

AWS Cognito handles a lot of things for your, it's key to understand what it does though! This lecture explores the Cognito Auth Flow.

Understanding the Cognito Auth Flow
03:19

We're going to add Cognito to an example web app in this course. The app is built with Angular. No worries, you don't need to know Angular!

The Example Web App, Angular and TypeScript
00:21

Time to add Cognito to a frontend app! This lecture gets you started with that step.

Adding Cognito to a Frontend App - Getting Started
05:28

Don't plan on building a web app? No problem at all, AWS Cognito also offers comparable SDKs for iOS and Android apps!

Using Cognito in iOS or Android Apps
00:12

Before users can sign in, they of course need to be able to sign up. Let's add such a functionality in this lecture.

Adding Signup to the Frontend App
12:00

It's great that users can sign up, but we probably want to verify their email address. Learn how to easily add user confirmation in this lecture.

Adding User Confirmation to a Frontend App
04:08

Users are able to sign up and confirm their mail addresses, time to provide a login functionality!

Adding Signin to a Frontend App
05:50

We also want to manage the user state (e.g. "Is the user logged in?"). Learn how to easily implement that via Cognito.

Managing User State with Cognito
03:48

Now that Cognito handles the full authentication flow, it's time to also use it to authorize incoming requests on API Gateway. Learn more about that in this lecture.

Using a Cognito Authorizer with API Gateway
02:46

With the change from a custom authorizer to a Cognito authorizer, we also need to adjust the way we pass the ID on to Lambda.

Passing the right User ID to Lambda
06:43

We could almost finish the app now but let's also learn how to use Cognito from within a lambda function and how to pass query params to an API endpoint.

Using Query Params & Cognito from Lambda
07:59

In the last lecture, we used the Cognito Identity Service Provider. Want to learn more about the methods we used? This lecture helps you!

More on the Cognito Identity Service Provider
00:11

We expect to get query params on the backend, we should therefore probably pass them from the frontend. Let's do so now!

Passing Query Params from the Frontend
03:50

We're almost done with this module, let's now also pass the user id to the DELETE API endpoint.

Passing the User Id to the DELETE Endpoint
05:05

Let me wrap this module up and summarize what we learned!

Wrap Up
01:46
+
Hosting a Serverless SPA
16 Lectures 37:41

Let me introduce you to this module and what you're going to learn in it!

Module Introduction
02:00

For hosting a serverless SPA, we're going to use S3. Learn more about that service in this lecture.

What is S3?
02:32

Want to dive deeper into AWS S3? This lecture provides some useful resources!

AWS S3: Useful Resources & Links
00:16

We learned what AWS S3 is, let's now use this knowledge to create a S3 bucket!

Creating a S3 Bucket
04:30

We got a bucket and ultimately, we'll use this bucket to host our web app. Time to learn how to get the web app into the bucket!

Uploading the Web App to the Bucket
02:47

Turns out that we can use a S3 Bucket as a static web server. Learn how that works in this lecture.

Turning a S3 Bucket into a Static Webserver
03:39

Would be nice to also know who visits our page, wouldn't it? Learn more about how to set up logging in this lecture.

Setting up Logging
01:53

Our web page is getting served by S3 but we can actually improve the way we deliver our content. Learn how and with which service in this lecture.

Optimizing Content Delivery: What is AWS CloudFront?
02:28

Want to dive deeper into AWS Cloudfront? Have a look at this lecture!

AWS CloudFront: Useful Resources & Links
00:12

When working with CloudFront, we work with "Distributions". Learn more about how to set up such a distribution in this lecture!

Setting up a CloudFront Distribution
04:39

Let's apply some finishing touches and re-visit our web app, now served via CloudFront.

Finishing the CloudFront Setup
01:08

To wrap this module up, it would be nice to use our own custom domain. Learn how Route53 helps you with that in this lecture.

Using a Custom Domain: What is Route53?
01:15

As always, if you want to dive deeper into Route53, these resources and links should be helpful!

AWS Route53: Useful Resources & Links
00:13

Time to register our own domain! This lecture will walk you through the required steps!

Registering a Domain
01:52

With the Domain registered, it's time to connect it to a CloudFront distribution. This lecture explains and hows how that works.

Connecting a Domain to a CloudFront Distribution
07:01

Let me wrap this module up and summarize it for you.

Wrap Up
01:15
+
Beyond the Basics - An Outlook
17 Lectures 01:01:31

Let me introduce you to this course module.

Module Introduction
03:13

If you plan to publish your API, you should also ensure that it's well-documented. Learn how to do this in this lecture.

Documenting an API
02:10

Other AWS Lambda Triggers
08:00

For the entire course, we had a look at serverless APIs (and SPAs). However, you can also host a Node/Express MPA serverless. Learn how that works in this lecture.

Going Serverless with a Node/ Express App (Non-API!)
01:58

Let's take a closer look at how we may actually get our app to run serverless via Lambda + API Gateway.

Running Node/ Express Apps via Lambda + API Gateway
09:24

Now that we had a look at how to set a serverless MPA with Node/Express up, let's also examine the pros and cons of this approach.

Pros and Cons of Serverless Node/Express MPA
03:08

Do you want to dive deeper into serverless MPAs powered by express? Check this article!

Learn more about AWS Serverless + Express Apps
00:08

Security matters! Always! Learn which potential security issues you need to care about and what AWS does for you when it comes to security.

Serverless Apps and Security
12:04

Thus far, we mostly worked in the Lambda inline editor or uploaded ZIP files. For bigger apps, that might not be the approach you want to use though.

A Case of a Better Development Workflow
01:03

If you want to work with a better, more streamlined development workflow, the Serverless Framework might be what you're looking for. In this lecture, we'll take a closer look.

Getting to know the Serverless Framework
06:02

Want to dive deeper into the serverless framework? Here you go!

More about the Serverless Framework
00:11

We learned about the Serverless Framework - AWS also has its own alternative. Well, kind of an alternative. Learn more about the Serverless Application Model in this lecture.

Getting to know SAM (Serverless Application Model) by AWS
03:40

SAM is your thing? Have a look at this lecture for more useful resources!

More about the Serverless Application Model (SAM)
00:08

What about testing? So far, we mostly had a look at CloudWatch logs. There's nothing wrong about that, but there also are better solutions. Learn more, in this lecture!

Testing Serverless Apps with localstack
03:18

AWS offers a lot of services and there are some services, which might particularly interesting to you. This lecture takes a closer look.

Other useful AWS Services
05:38

Let me wrap this module up and summarize it for you!

Wrap Up
01:11

Besides the already linked pages about SAM etc, here are some other useful links regarding localstack and the presented AWS services.

Useful Resources & Links
00:13
+
Course Roundup
1 Lecture 01:00

Let me round this course up and give you an overview over what you learned!

Roundup
01:00
About the Instructor
Maximilian Schwarzmüller
4.7 Average rating
50,054 Reviews
151,599 Students
16 Courses
Professional Web Developer and Instructor

Experience as Web Developer

Starting out at the age of 13 I never stopped learning new programming skills and languages. Early I started creating websites for friends and just for fun as well. This passion has since lasted and lead to my decision of working as a freelance web developer and consultant. The success and fun I have in this job is immense and really keeps that passion burningly alive.

Starting web development on the backend (PHP with Laravel, NodeJS) I also became more and more of a frontend developer using modern frameworks like Angular or VueJS 2 in a lot of projects. I love both worlds nowadays!

As a self-taught developer I had the chance to broaden my horizon by studying Business Administration where I hold a Master's degree. That enabled me to work in a major strategy consultancy as well as a bank. While learning, that I enjoy development more than these fields, the time in this sector greatly improved my overall experience and skills.

Experience as Instructor

As a self-taught professional I really know the hard parts and the difficult topics when learning new or improving on already-known languages. This background and experience enables me to focus on the most relevant key concepts and topics. My track record of many 5-star rated courses, more than 100.000 students on Udemy as well as a successful YouTube channel is the best proof for that.

Whether working as development instructor or teaching Business Administration I always received great feedback. The most rewarding experience is to see how people find new, better jobs, build awesome web applications, acquire amazing projects or simply enjoy their hobby with the help of my content.