Simple Auto Scaling
A full course that teaches you how to create auto scaled infrastructure start-to-finish, without confusing configurations or complex technologies. Learn the AWS fundamentals with a real-world use case!
Get notified when this course launches, and start learning some hard-earned knowledge now!
- 0 Videos
Keeping Sane in AWS
See how to quickly create an auto scaling infrastructure that's simple enough to understand, while leveraging the most powerful parts of AWS.
Learn the details of AWS core services while auto scaling web and queue worker servers. No need for a doctorate in clustered technologies.
What you'll learn about AWS
AWS is powerful, but complicated. This course teaches you the important fundamentals of AWS, clearly and simply.
Create private networks and learn a simple - but powerful - configuration for handling secure private and public network communication.
EC2 servers have an incredible range of configuration options. We demystify these options so you know what you're choosing.
Automate when and how AWS will scale servers in and out. Learn how to separately scale web servers and worker servers.
Learn how to configure Application Load Balancers to easily integrate with auto scaling.
Setup a pipeline to automate testing and see what options are available for deploying your applications.
Setup managed services (such as RDS) and see what it looks like to securely communicate over the private network.
Knowledge You'll Reuse
We cover the foundations of AWS that you'll use forever. Learn about the VPC, and about everything you can configure in EC2. See why AWS Auto Scaling is its killer feature.
Infrastructure as Code
Clicking around the web interface is a recipe for disaster. Learn how to track your infrastructure, allowing for you to copy, tweak, destroy, and recreate everything.
Directly to Production
Cut a path through the myriad of AWS services to see the simplest way to production. Trigger CI/CD pipelines, and deploy your code to auto scaled environments.
Made with Laravel
We use a Laravel application to demonstrate auto scaling on AWS.
This includes creating deployable "build artifacts", using PHP web servers, automating queue
worker servers, auto scaling each server type separately, managing
.env files (secrets), and more!
We see how to handle IP addresses when creating a VPC and thinking about the subnets.
We get a bit more in-depth on creating subnets and choosing their IP address ranges.
About VPC Gateways
We explore Internet Gateways and NAT Gateways to see how they help us create private and public subnets.
We create a server in the EC2 web console to get a sense for what this course will cover.
T3 CPU Credits
We talk about T class instances (T3 in this case), and go in-depth on CPU credits.
We cover the options available when configuring an EC2 instance in the web console.
SSH Key Pairs
We discuss creating and using SSK Key Pairs in AWS so we can SSH into our instances.
EC2 Dashboard Review
We discuss the various areas in the EC2 control panel, describing what they are used for.
The Server Base Image
We cover the AMI (Amazon Machine Image) used to create a server image. This server image has everything we need to run our application as either a web server or queue worker.
Introducing Launch Templates
We cover what a Launch Template is within AWS, and why we would use them to help auto scale EC2 servers.
We create a few security groups needed for our use case - web servers behind load balancers, and queue worker servers.
User Data Scripts
We're just about ready to create our Launch Templates. We'll start by creating some User Data scripts, which run when the server is first booted up.
Using our Launch Templates
We use our new Terraform module to create 2 Launch Templates. One Launch Template will be for our web servers, while another is for queue worker servers.
Auto Scaling Groups
We learn about what Auto Scaling Groups are, and a little bit about how they operate.
Creating Auto Scaling Groups
We see what it looks like to create an ASG in the web UI, and explore the areas of the ASG web UI.
ALB Health Checks
I created a Load Balancer to demonstrate how ASG's can integrate with them. In this case, the ALB can tell the ASG when an instance has failed a health check, which lets the ASG know to replace the failed instance.
Target Tracking Auto Scale Policy
We create our first Auto Scaling Policy - a Target Tracking policy to keep our average CPU usage to a certain target.
We show a created CodeBuild project, review it's configuration, and see what it looks like to run a build using the buildspec file!
Elements of a CodeBuild Project
We cover all the options presented to you when creating a CodeBuild project within the UI and as a Terraform resource.
CodeBuild in Terraform
We create our CodeBuild project using Terraform, quickly cover the BuildSpec file, and get up and running!
We adjust our CodeBuild project to use it's built-in artifact handler, and then describe why we won't be using it.
Manually Creating Artifacts
We update the sample application, adding a script which creates a build artifact.
We see a Deployment Application in action, and cover what we'll do in this module to get our deployments working.
The CodeDeploy Agent
To use CodeDeploy, our EC2 servers will need the CodeDeploy agent installed onto them. We'll see how to do that.
Disable the Auto Scaling Policy
We disable the auto-scaling policy to better see deployments work on multiple servers.
Server Instance Profile
The servers being deployed to need permissions to do certain things, such as download a build artifact from S3.
Defining a CodeDeploy Group
We complete our CodeDeploy configuration, covering the more complex portion of our configuration
We kick off a deployment manually to test everything out and see how it works.
A Note on Database Migrations
We take a quick second to discuss how to handle database migrations.
Destroying Current Infrastructure
We'll destroy our current infrastructure to make it easier to refactor. We hit a hiccup with deleting an S3 bucket.
Refactoring Terraform Environments
We begin refactoring our Terraform configuration, setting it up to handle multiple environments.
The Shared Environment
We setup the shared environment, which is where we will put the CodeBuild project.
Updating the Main Environments
We update our staging/production environments so they know about the artifact bucket, which was created in the shared environment.
Creating a Helper Script
We create a helper script to remove some boiler plate from our Terraform commands and make our lives a bit easier.