**NOTE: This course has been retired because it uses AWS CDK v1. [Navigate to version 2 of the course here](https://egghead.io/courses/full-stack-typescript-with-aws-cloud-development-kit-v2-2daa5cf1)** 

Amazon AWS is one of the most popular cloud providers in the world, but it can also be daunting to learn thanks to the alphabet soup of service acronyms.

Once you've figured out which subset of services to use, you've got a lot of clicking around to do in order to get things configured.

Not anymore!

With the AWS Cloud Development Kit (CDK), you are able to configure AWS services from your terminal & editor.

Even better, you can do your configuration, frontend, and backend all with the same language. 

In this course, Tomasz Łakomy will guide you through using TypeScript to complete the lifecycle of an application powered by AWS CDK. You'll see how to start a project, develop it locally, deploy it globally, then tear it all down when you're done.

The services & development approach Tomasz demonstrates in this course are used by countless companies around the world. 

Is yours next?

Hello and welcome to "Build an App with the AWS Cloud Development Kit"!

In this lesson I'd like to give you a quick overview of what kinds of things you're going to learn in this course as well as what kind of resources you can use in order to get a better understanding of the concepts we'll cover.

Introduction to Build an App with the AWS Cloud Development Kit

All amazing projects have to start somewhere and AWS CDK is no exception.

In this quick lesson we're going to learn how to install AWS CDK command line interface with `npm` as well as how to use `cdk init` in order to create our very first CDK project 🥳

Install AWS Cloud Development Kit (CDK) and create a new project

Now that our initial AWS CDK project has been created, it's time to deploy it!

In this quick lesson we're going to learn:
- where do we define an AWS CDK stack
- what is a CDK construct (you can read more about CDK construct [here](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html) )
- how to use `cdk diff` command in order to see the difference between our currently deployed stack and the stack we're about to deploy
- how to use `cdk deploy` in order to deploy a CDK stack to AWS

Build and deploy a sample AWS Cloud Development Kit stack to AWS

Now that our initial stack has been deployed it's time to dig into AWS Console to see what exactly did we deploy.

Cloud Development Kit is built on top of CloudFormation which is an AWS service that allows you to describe a stack in AWS using a static file (either YAML or JSON).

In essence - it's going to convert our code written in TypeScript, to JavaScript, which will be then converted to CloudFormation and CloudFormation will be used to deploy our infrastructure.

Sounds complicated, right? Luckily CDK abstracts a lot of things away from us, so we get to focus on solving our problems instead of writing YAML by hand.

In this lesson we're going to learn how to review an AWS CDK stack deployment in CloudFormation console.

Review an AWS CloudFormation stack deployed with AWS CDK

In this quick lesson we're going to clear out the SQS Queue and SNS Topic that was created for us when we created a CDK app with `cdk init` in order for us to be able to start building our app from scratch.

Clear an initial AWS CDK stack to start building an app from scratch

It's time to start building our serverless backend!

In this quick lesson we're going to use the `lambda.Function` construct imported from `@aws-cdk/aws-lambda` in order to build and deploy a 'Hello World!' AWS Lambda function.

You can find out more about what kind of constructs are available in AWS CDK construct library [here](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-lambda-readme.html)

Create and deploy a lambda function with AWS CDK

In the previous lesson we've managed to successfully create and deploy an AWS Lambda function.

Before we progress further, in this lesson we're going to quickly take a look at AWS Console in order to understand where exactly can we find the stack that we've deployed and also execute the lambda function using a test event to make sure that it's working fine.

Review and execute a lambda function deployed with CDK in AWS Console

Every resource we deploy to AWS with CDK has some default values configured for us so that we don't have to configure everything ourselves.

This comes in handy because it allows us to focus on building our infrastructure and solving our problems instead of configuring everything.

With that being said - CDK allows us to configure various properties of our resources! In this quick lesson we're going to learn how to configure the memory size and timeout of an AWS Lambda function.

Change the properties of a lambda function deployed with AWS CDK

Serverless technologies like AWS Lambda allow us to build our applications out of small, independent functions that can be called based on events such as an API call.

By default, it's not possible to call a lambda function from the Internet - it's safely stored within AWS cloud, following the principle of least privilege.

In order to create a REST API to call a lambda function we need to use [API Gateway](https://aws.amazon.com/api-gateway/). Luckily, with AWS CDK, we can create a `LambdaRestApi` in 3 lines of code and this is exactly what we're going to learn in this quick lesson!



Attach an API Gateway to a lambda function deployed with AWS CDK

Environment variables are really useful in programming - they allow us to avoid hardcoding secrets (such as API keys) in our code with added bonus of using different values depending on the environment (hence the name!).

In this quick lesson we're going to learn how to pass environment variables to an AWS Lambda function deployed with Cloud Development Kit (in a single line of code!)

Pass environment variables to a lambda function deployed with AWS CDK

Building and debugging lambda functions can be tricky.

Once a function becomes non-trivial, the cycle of:

- build
- deploy to AWS
- test
- fix
- repeat

wastes *a lot* of time. Luckily, there's an alternative.

In this quick lesson we're going to learn how to use AWS Serverless Application Model (SAM) command line interface in order to execute a lambda function built with CDK locally.

This lesson is a bit optional because it touches a topic that is not going to be relevant for the rest of this course (although running lambda functions locally is *really* useful).

If you'd like to learn more about AWS SAM, there's a whole collection about it: [Build serverless applications with AWS Serverless Application Model (AWS SAM)
](https://egghead.io/playlists/learn-aws-serverless-application-model-aws-sam-framework-from-scratch-baf9)

Run lambda functions built with CDK locally using AWS SAM

Lambdas and API Gateways are not the only type of AWS resource we can deploy to AWS cloud using CDK. In fact - nearly every resource that is deployable (is that a word?) with CloudFormation, can also be deployed with AWS CDK.

One of the most popular services on AWS is Amazon S3, which stands for Simple Storage Service.

As the name suggests - it's nothing but simple (in my humble opinion), luckily creating a new S3 bucket and deploying it to the cloud using CDK is relatively straightforward.

Files on S3 are stored in things called "buckets", which are unlimited in size and each bucket has a globally unique name.

In this quick lesson we're going to create and deploy a brand new S3 bucket to AWS with CDK

Create and deploy an S3 bucket with AWS CDK

Files uploaded to an S3 bucket are not accessible by default from the Internet.

Which makes sense - by default they should be secure, but since we'd like to host a logo file to be displayed in our app, we need to make the bucket public.

Luckily, with CDK we need to literally change a single line of code - in this quick lesson we're going to learn how to make the contents of an S3 bucket public.

Make the contents of an S3 bucket deployed with CDK public

A huge part of building serverless applications with AWS is being able to connect certain cloud resources and have them react to certain events.

Currently our HelloLambda function can be triggered by a GET request event sent to the API Gateway, but that's not the only use case when a lambda function can be triggered.

Suppose we'd like to trigger the lambda function whenever a file is uploaded to an S3 bucket, for instance, to generate a thumbnail. Once a thumbnail is generated, lambda function can call another function etc., this behaviour is up to us to define.

In order to call a lambda function when a file is uploaded to an S3 bucket, we need to use an `s3Notifications` construct - and that's exactly what we're going to do in this quick lesson.

Create an S3 event notification to trigger a lambda function on file upload

Instead of uploading the files manually through the AWS console, a better solution would be to automatically upload the `asset` directory (or any other directory we'd like to upload) whenever we deploy our stack. After all, with CDK we'd like to reduce the manual work to minimum and focus on building an architecture and solving our problems.

In this lesson we're going to learn how to use the `aws-s3-deployment` construct in order to upload an `assets` directory to an s3 bucket automatically whenever we deploy the CDK stack.

Use a bucket deployment to upload a file to S3 when deploying a CDK stack

Now that we know a lot about shipping cloud resources with CDK it's time to start creating a serverless backend for our todo application.

We could add the database and new lambda functions to our main stack but after a while it might get difficult to maintain. 

Instead, in this lesson we're going learn how to create our very own custom CDK construct

Learn more about CDK constructs [here](https://docs.aws.amazon.com/cdk/latest/guide/constructs.html)

Create a custom AWS CDK construct

Amazon DynamoDB is a fully managed non-relational (NoSQL) database service that provides fast and predictable performance with seamless scalability.

In other words - DynamoDB is entirely managed by AWS (so it's scaled for us, even if our startup has millions of users), it's a NoSQL database so we don't have to start by defining a detailed schema like in a relational database and it's used by companies like AirBnB, Lyft and Samsung in production.

In this quick lesson we're going to learn how to create a brand new DynamoDB table from scratch with AWS CDK.

Create a DynamoDB table with AWS CDK

Now we're getting somewhere 🎉

Our stack has plenty of resources and how it's the time to start combining them together.

In this lesson we're going to create a new lambda function that will read data from our new `TodoTable`.

Since we don't want to add unnecessary noise, we're going to define the lambda function in the `TodoBackend` stack. 

After all - whoever will end up using that stack shouldn't have worry too much about the underlying details. That's the power of CDK - we get to abstract away unnecessary implementation details and focusing on solving problems by deploying infrastructure and resources we need to solve them.

Get all items from a DynamoDB table deployed with CDK using DocumentClient API

At the end of the last lesson we've managed to create a Lambda function which we want to use to get data from DynamoDB table using the scan operation.

Unfortunately, after calling the lambda function we get a following response:

```
"message": "User: arn:aws:sts::696785635119:assumed-role/TodoAppStack-TodoDatabaseTodoHandlerServiceRole991-152UNT6KUIOG2/TodoAppStack-TodoDatabaseTodoHandlerDD6198FE-CPTO6AAJJU5W is not authorized to perform: dynamodb:Scan on resource: arn:aws:dynamodb:eu-central-1:696785635119:table/TodoAppStack-TodoDatabaseTodoTable29EA4913-E6Z09XSAAHF8",
```

In this quick lesson we're going to learn two things:
* how to debug permission issues in AWS using CloudWatch
* how to allow a lambda function to access data from a DynamoDB table with `grantReadWriteData` function (in a single line of code!)



Debug permission issues and allow a lambda function to access data from a DynamoDB table

In this quick lesson we're going to expand our `todoHandler.ts` lambda function in order to implement a `addTodoItem` method with `AWS.DynamoDB.DocumentClient` `put` operation

Adding data to a DynamoDB table with put operation

The best kind of todo is the one we already did and we can delete it from the list 🎉

In this quick lesson we're going to learn how to delete an item from our DynamoDB table with a `AWS.DynamoDB.DocumentClient` `delete` operation

Delete an item from a DynamoDB table with delete operation

Most JavaScript projects use some (sometimes even too many) external dependencies. AWS Lambda functions written in node.js are no different - it's quite common to use packages from npm in order to ship our code faster and provide value to our users.

Luckily, CDK helps us here as well - in this quick lesson we're going to learn how to add external dependencies to an AWS Lambda function deployed with AWS CDK. We're also going to see where to find our code + dependencies after we deploy out stack to AWS.

Add external dependencies to an AWS Lambda function deployed with CDK

It is time.

Our serverless backend and infrastructure (that we both created *and* deployed ourselves with CDK!) is ready so we can connect it to our React app.

In this quick lesson we're going to learn how to connect the React app from the source code of this course to our API as well as how to add appropriate CORS headers to our API response.

Connect React app to a serverless backend deployed with CDK and fix CORS issues

Once we deploy static assets to an S3 bucket it's good to know, well, where are they exactly - saying that "they're in the cloud" is not a good answer.

We can find the S3 bucket and other resources in AWS Console manually but there's a better solution - creating custom CloudFormation stack outputs that are displayed in the terminal once we deploy.

In this quick lesson we're going to learn how to create a custom CloudFormation stack output in order to output the path to an egghead logo in order to add it to our app.

Add a custom CloudFormation stack output with CDK

Our app is now finished and it is time to show it to the world. 

In this quick lesson we're going to learn how to deploy a static website to S3 with AWS CDK so it is accessible from the internet and no longer lives only in our `localhost`.

Deploy a static website to S3 with AWS CDK

Deploying a static site to S3 works really well unless we consider the fact that you cannot add HTTPS support to the site directly in S3. In order to do that - a CloudFront distribution is required.

While it is possible to setup [CloudFront with CDK](https://docs.aws.amazon.com/cdk/api/latest/docs/aws-cloudfront-readme.html) on our own, we don't always have to do anything on our own.

Instead, we can use constructs that were created by the community. 

In this quick lesson we're going to learn how to use [CDK-SPA-Deploy](https://github.com/nideveloper/CDK-SPA-Deploy) construct in order to deploy our app to S3 (using `createBasicSite` construct) and deploy it with HTTPS support and behind a CloudFront CDN distribution.

**IMPORTANT NOTE:** All AWS Construct Library modules used in your project must be the same version.

Deploy a site with HTTPS support behind a CDN with CDK

When experimenting with CDK it's possible to deploy a service which is outside of free tier (since nearly all AWS services are supported) and it's useful to be able to delete an entire CDK stack if necessary.

In this quick lesson we're going to learn how to delete an entire AWS CDK stack with `cdk destroy` command.

Build an App with the AWS Cloud Development Kit

Instructor

Credits

What you'll learn

Credits

Course Content