AWS for Front-End Engineers (ft. S3, Cloudfront & Route 53)

Introduction
Introduction
00:00:00 - 00:07:23
Introduction
After discussing the dramatic performance gains by using AWS infrastructure, Steve Kinney reviews the course's agenda, and the demo application students will build. - - _https://gist.github.com/stevekinney/6ab02582829f039b6a14c973923909f8 - _https://www.dropbox.com/sh/thuoclvoj3r9nut/AADAA5rUqF5awNVxjyFLoh55a?dl=0
The AWS Free Tier
00:07:24 - 00:10:29
The AWS Free Tier
Steve examines available services that come with AWS's free tier. - _https://aws.amazon.com/free/
IAM and Account Management
Monitoring Billing
00:10:30 - 00:13:23
Monitoring Billing
Steve Kinney walks through how to set up an AWS budget and alert notifications, in case free tier limits are exceeded on AWS.
Securing the Root Account
00:13:24 - 00:18:18
Securing the Root Account
Steve sets up a new AWS account with a subuser and configures MFA on both accounts as well as discusses AWS's Identity Access Management (IAM).
Creating an IAM User
00:18:19 - 00:27:05
Creating an IAM User
Steve creates an administrator user that is separate from our root user and prompts students to set up two-factor auth on the newly created IAM administrator account.
Storage and Hosting with S3
Introducing S3
00:27:06 - 00:35:37
Introducing S3
Steve introduces Simple Storage Service (S3), one of AWS's oldest and most popular services. S3 is used for storing and hosting the course client-side application on the web.
Registering a Domain Name
00:35:38 - 00:39:48
Registering a Domain Name
AWS offers domain name registration through its Route 53 service. CloudFront wants S3 buckets that are named after the respective domain name. Since both domain names and bucket names are globally unique, make sure neither has already been used.
Policies
00:39:49 - 00:42:38
Policies
Steve explains how bucket policies work and how to generate policies for an S3 bucket.
Setting Up an S3 Bucket
00:42:39 - 00:52:56
Setting Up an S3 Bucket
Steve configures an S3 bucket for static web hosting. Along the way, he explores some of the additional features offered by S3.
The AWS CLI
Introducing the AWS CLI
00:52:57 - 00:57:43
Introducing the AWS CLI
Steve takes a quick tour of the AWS CLI. Steve also sets up named profiles and other configuration for the AWS CLI.
Deploying to S3 through the CLI
00:57:44 - 01:06:49
Deploying to S3 through the CLI
Steve uses the AWS CLI to build and deploy the course's React application to the S3 bucket configured for static web hosting.
DNS with Route 53
Introducing Route 53
01:06:50 - 01:09:00
Introducing Route 53
Steve introduces Route 53 along with a brief explanation of the Domain Name System (DNS).
Setting Up DNS
01:09:01 - 01:12:05
Setting Up DNS
Steve sets up the recently purchased domain name to use with the new static website that was created earlier.
Creating a SSL Certificate
01:12:06 - 01:14:55
Creating a SSL Certificate
Steve creates an SSL (Secure Sockets Layer) certificate using Amazon Certificate Manager to establish an encrypted link between the web server and a browser.
Routing with S3 and Route 53
Client-side Routing and S3
01:14:56 - 01:19:29
Client-side Routing and S3
Steve solves a bug where client-side routes cannot be navigated to directly — the best way he can for now.
Setting Up a WWW Subdomain
01:19:30 - 01:24:09
Setting Up a WWW Subdomain
Steve sets up a second S3 bucket for redirecting from the "www" subdomain (e.g., _http://www.example.com) to the bare domain (e.g., _http://example.com). He also configures the DNS settings in Route 53 to work with the new bucket.
CloudFront
Creating a Cloudfront Distribution
01:24:10 - 01:25:51
Creating a Cloudfront Distribution
CloudFront takes a few minutes to set up, so Steve starts by creating a CloudFront distribution for the application that was deployed earlier.
Re-Routing DNS
01:25:52 - 01:35:32
Re-Routing DNS
Steve redirects Route 53 from the S3 bucket in us-east-1 to CloudFront.
CloudFront Overview
01:35:33 - 01:45:36
CloudFront Overview
While waiting for the CloudFront set up to complete, Steve more formally reviews AWS's content delivery network (CDN).
Error Pages with CloudFront
01:45:37 - 01:49:58
Error Pages with CloudFront
Steve readdresses the problem with client-side routes and answers questions from students.
Cache Invalidations
01:49:59 - 01:55:25
Cache Invalidations
To deploy a new version of an application, Steve demonstrates how to invalidate versions of the previous version at the edge nodes of CloudFront.
Setting Up a Build Pipeline
Introducing CI/CD with Travis CI
01:55:26 - 01:56:55
Introducing CI/CD with Travis CI
Steve sets up Travis CI to automatically deploy new versions of the application to S3 as well as remove previous versions of the application by invalidating CloudFront's caches.
Setting Up a Travis Configuration File
01:56:56 - 02:05:26
Setting Up a Travis Configuration File
Steve shares a .travis.yml template to make deploying to S3 and CloudFront easier.
Creating Another IAM User and Policy
02:05:27 - 02:10:27
Creating Another IAM User and Policy
Steve creates another create another IAM user with restricted permissions to keep from sharing administrator credentials with Travis CI.
Pushing a Change with CI
02:10:28 - 02:14:38
Pushing a Change with CI
With a new IAM user set up with a custom restricted AWS policy in place, Steve deploys the course application with Travis CI. Steve takes questions from students.
Build Pipeline Review
02:14:39 - 02:15:33
Build Pipeline Review
Make a new commit to master and push it up to GitHub to trigger a new build. Steve takes questions from students.
Lambda@Edge
Introducing Lambda@Edge
02:15:34 - 02:25:09
Introducing Lambda@Edge
Steve introduces Lambda@Edge, a new service from AWS that allows you to deploy Lambda functions to your CloudFront Edge nodes.
Solving Client-Side Routing Issues
02:25:10 - 02:43:54
Solving Client-Side Routing Issues
Steve walks-through setting up a Lambda@Edge function for resolving client-side routing problems and 404 File Not Found errors.
Swapping Out Image Requests Exercise
02:43:55 - 02:48:50
Swapping Out Image Requests Exercise
Steve uses Lambda@Edge to manipulate HTTP requests on the fly.
Adding Security Headers
02:48:51 - 02:57:02
Adding Security Headers
Steve audits the security of our new application, and it fails, so he writes a Viewer Response function to address the holes in the application.
Redirecting Responses
02:57:03 - 03:07:42
Redirecting Responses
Steve sets up an Origin Request function to create a 302 redirect for a particular route. Steve takes questions from students.
Wrapping Up
Final Thoughts
03:07:43 - 03:12:31
Final Thoughts
Steve discusses further ways to improve the build and deployment process with Terraform or CloudFormation.
Q&A
03:12:32 - 03:16:14
Q&A
After taking questions from students about automation with Lambda and using CloudFront in front of an organization's own servers, Steve wraps up the course.