Week 3 — Infrastructure as Code & Containerization

Hi Inner Circle,

Welcome to Week 3.

Last week, we covered the backbone — networking, IAM, and storage.

I hope you’re solid on those foundations, because as we go further, things are going to get COMPLEX— I mean very COMPLEX (yes, the caps are on purpose ~ take this seriously!).

This week, we’re stepping into the muscle of the cloud: infrastructure and compute.

Every application ultimately needs to “run” somewhere.

For years, that meant a virtual machine you spun up manually and configured line by line. Over time, the industry has moved toward automation and containers, and in Week 4 we’ll take this further into serverless and Kubernetes.

Let’s break down the journey.

⸻

Virtual Machines & the Old Way of Provisioning

In the early cloud days, deploying an app meant:

1. Launch a VM → Go to AWS EC2 or GCP Compute Engine, select an OS, and boot an instance.

2. Manually SSH in → Install dependencies (apt-get install nginx), configure your web server, and tweak settings.

3. Repeat → Every new server required the same steps — often prone to human error.

Resources:

• AWS EC2 Launch Tutorial

• GCP Compute Engine Quickstart

• Mini Project: Spin up a Linux VM, SSH in, and install Nginx - YouTube Video here.

  ⸻

Snapshots & Images

Manual configuration is fragile. If a VM crashes, you don’t want to rebuild everything.

• Snapshots: Capture the disk state of a VM.

• Images: Create reusable templates (AWS AMIs, GCP Custom Images) that can launch pre-configured servers.
  

Resources:

• Create AMI from EC2 Instance

• GCP Custom Images

• Another video tutorial here ( note the configuration steps can be used to deploy in any cloud provider)

Mini Project: Install Nginx on a VM → create an image → launch a new VM from that image → confirm it already has Nginx running.

⸻

Infrastructure as Code (IaC): The Modern Flow

Snapshots helped, but they didn’t solve configuration drift. Teams started writing shell scripts (bash, Ansible, Chef, Puppet) to configure servers after launch.

That worked… until infra grew into hundreds of servers across multiple regions.

This is where Infrastructure as Code (IaC) came in.

The evolution:

Why IaC matters:

• Declarative: Describe what you want, not step-by-step how to do it.

• Versioned: Store in Git, review changes like code.

• Automated: Provision hundreds of servers with one command.

• Consistent: Same template works across environments.

Quick comparison of IaC tools:

Resources:

• Terraform Tutorial

• AWS CloudFormation EC2 Example

• Mini Project: Write a Terraform file that provisions a VM with Nginx. Destroy and recreate it with one command.

• Reference videos here.

⸻

Containerization: The Docker Fundamentals

Even with IaC, VMs are still “heavy.” Each VM runs a full OS, which means slower startup and more overhead.

Docker is the prerequisite for Kubernetes. Know these commands to manage your containerized applications locally.

Resource: Work through this great, simple Hello World Node.js Docker project on GitHub to practice your commands: github.com/dockersamples/helloworld-demo-node.

Resources:

• Docker Get Started

• Dockerfile Best Practices

⸻

Container Registries

Now you need a way to share containers. Enter registries:

• Public: Docker Hub

• Private: AWS ECR, GCP Artifact Registry, Azure Container Registry

• Why it matters: Registries are the “app stores” for containers. Without them, DevOps pipelines can’t scale.

Resources:

• Push Image to Docker Hub

• Amazon ECR Tutorial

• GCP Artifact Registry

• Another reference video here.

• Mini Project: Push your Nginx container to Docker Hub and pull it on another machine.

⸻

PaaS Deployments

What if you don’t want to manage VMs or clusters at all?

• Platforms like Google App Engine let you deploy an app directly managing runtime and other dependencies. You get an option to choose container based environments as well.

• The provider manages scaling, patching, and infra.

Resources:

• Deploy with AWS Elastic Beanstalk

• GCP App Engine Quickstart

Mini Project: Deploy your Nginx app on App Engine or Elastic Beanstalk. Compare setup effort vs running it on a VM.

⸻

Action Items for Week 3

• Launch a VM, SSH in, and install Nginx.

• Take a snapshot/image and relaunch from it.

• Write a Terraform file to deploy the same VM automatically.

• Containerize Nginx with Docker.

• Push your image to Docker Hub or a cloud registry.

• Deploy to PaaS and compare experience.

⸻

Conclusion

That’s your TL;DR for Week 3.

We started with the old way (manual VMs), evolved to images and automation, and ended with containers and PaaS. This is the natural journey cloud teams went through — and the one you should practice too.

Next week → we’ll push forward into Serverless and Kubernetes. You’ll learn how functions scale without servers and how Kubernetes orchestrates containers at scale.

Good Luck with this week!

-V

Seeking impartial news? Meet 1440.

Every day, 3.5 million readers turn to 1440 for their factual news. We sift through 100+ sources to bring you a complete summary of politics, global events, business, and culture, all in a brief 5-minute email. Enjoy an impartial news experience.

Join for free today!