AWS Serverless APIs & Apps - A Complete Introduction

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

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

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.

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.

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

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?

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

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

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

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

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.

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

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

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

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

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.

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

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

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 enhanced the Lambda console - learn what's new!

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!

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

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

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

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

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

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.

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

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

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.

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

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

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

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

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

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

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

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.

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

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

Let me introduce you to this module.

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?

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

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

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.

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

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

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

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.

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

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

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

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.

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

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.

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.

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.

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.

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!

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

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

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.

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!

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.

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

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

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

Let me introduce you to this module.

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

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!

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

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.

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

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

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!

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!

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

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

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

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.

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!

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

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

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

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.

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

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

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.

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.

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.

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

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

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

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

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

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

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

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

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!

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

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

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.

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

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

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

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.

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

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

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

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

Let me introduce you to this course module.

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

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.

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

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.

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

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

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.

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.

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

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.

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

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!

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

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

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

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