Cloud Computing · Course Modules
Cloud Computing Course Modules Explained Week by Week
Quick summary — cloud course modules week by week
A typical cloud computing course runs from foundations (cloud basics, accounts, IAM and networking) through core services (compute, scaling, storage and databases) to operations (monitoring, security, cost and Terraform) and ends with a capstone project. Each week should pair concepts with labs; confirm the official order and duration with the provider.
In this guide you will learn:
- What each week — typically covers.
- The labs — you should expect.
- Example code — from key modules.
- A weekly study tracker — and capstone plan.
- Interview questions — mapped to modules.
SECTION 01Weeks 1-3: foundations, IAM and networking
The first weeks build the base everything else depends on. You learn what cloud computing is, set up an account safely with MFA and budget alerts, and learn identity and access management so you never use the root account for daily work. Networking follows: virtual networks, subnets, routing and security groups. This breakdown is typical; the official module list may differ:
| Week | Topics | Lab | Why it matters |
|---|---|---|---|
| Week 1 | Cloud concepts, regions, service models, account safety | Account with MFA and budget alert | Safe start |
| Week 2 | IAM users, groups, roles, policies | Least-privilege role | Security foundation |
| Week 3 | VPC, subnets, route tables, gateways, security groups | Public and private subnets | Network design |
| Review | Foundation recap and quiz | Diagram your VPC | Check understanding |
#!/usr/bin/env bash
# Create a role EC2 can assume, with read-only S3 access
set -euo pipefail
cat > trust.json <<'JSON'
{"Version": "2012-10-17",
"Statement": [{"Effect": "Allow",
"Principal": {"Service": "ec2.amazonaws.com"},
"Action": "sts:AssumeRole"}]}
JSON
aws iam create-role --role-name course-ec2-s3-read \
--assume-role-policy-document file://trust.json
aws iam attach-role-policy --role-name course-ec2-s3-read \
--policy-arn arn:aws:iam::aws:policy/AmazonS3ReadOnlyAccess
VPC 10.0.0.0/16 (ap-south-1)
|
|-- Public subnet A 10.0.1.0/24 (AZ a) -> route 0.0.0.0/0 to Internet Gateway
|-- Public subnet B 10.0.2.0/24 (AZ b) -> route 0.0.0.0/0 to Internet Gateway
|-- Private subnet A 10.0.11.0/24 (AZ a) -> route 0.0.0.0/0 to NAT Gateway
`-- Private subnet B 10.0.12.0/24 (AZ b) -> route 0.0.0.0/0 to NAT Gateway
Security groups:
web-sg: allow 443 from internet
app-sg: allow app port from web-sg only
db-sg: allow database port from app-sg only
SECTION 02Weeks 4-7: compute, scaling, storage and databases
With foundations in place, the middle weeks cover the services that run applications. You launch virtual servers, put them behind a load balancer, add auto scaling, store files in object storage with lifecycle rules, attach block storage and set up a managed relational database in private subnets. Each week ends with a lab that adds a piece to a growing application:
| Week | Topics | Lab | Why it matters |
|---|---|---|---|
| Week 4 | EC2 instances, AMIs, key pairs, user data | Web server via user data | Running workloads |
| Week 5 | Load balancers, auto scaling, health checks | Scaling web tier across two zones | High availability |
| Week 6 | S3, storage classes, lifecycle, EBS | Private bucket with lifecycle rules | Storing data safely |
| Week 7 | RDS, Multi-AZ, backups; DynamoDB intro | Private database for the app | Managed data |
#!/bin/bash
# EC2 user data: runs on first boot (Amazon Linux 2023)
dnf install -y nginx
cat > /usr/share/nginx/html/index.html <<'HTML'
<h1>Cloud course web server</h1>
<p>Served from an EC2 instance.</p>
HTML
systemctl enable --now nginx
{
"Rules": [
{
"ID": "archive-old-reports",
"Status": "Enabled",
"Filter": { "Prefix": "reports/" },
"Transitions": [ { "Days": 30, "StorageClass": "STANDARD_IA" } ],
"Expiration": { "Days": 365 }
}
]
}
# Apply with:
# aws s3api put-bucket-lifecycle-configuration --bucket <name> \
# --lifecycle-configuration file://lifecycle.json
SECTION 03Weeks 8-12: monitoring, security, Terraform and capstone
The final weeks focus on running systems well. Monitoring with metrics, logs and alarms shows when something goes wrong. Security and cost weeks cover encryption, secrets, auditing and budgets. Terraform then recreates your architecture as code, so it is repeatable. The course typically ends with a capstone project that brings everything together, followed by review and interview preparation:
| Week | Topics | Lab | Why it matters |
|---|---|---|---|
| Week 8 | CloudWatch metrics, logs, alarms, dashboards | Alarm on high CPU and errors | Visibility |
| Week 9 | Encryption, KMS, secrets, CloudTrail, cost tools | Encrypted storage; audit trail; budget | Security and cost |
| Weeks 10-11 | Terraform: providers, resources, modules, state | VPC and app tier in code | Repeatable infrastructure |
| Week 12 | Capstone and interview preparation | Complete project with diagram | Portfolio proof |
#!/usr/bin/env bash
# Alarm when average CPU stays above 70% for 10 minutes
set -euo pipefail
INSTANCE_ID=${1:?usage: $0 <instance-id>}
aws cloudwatch put-metric-alarm \
--alarm-name "course-high-cpu-$INSTANCE_ID" \
--namespace AWS/EC2 --metric-name CPUUtilization \
--dimensions Name=InstanceId,Value="$INSTANCE_ID" \
--statistic Average --period 300 --evaluation-periods 2 \
--threshold 70 --comparison-operator GreaterThanThreshold
# main.tf (Terraform >= 1.5)
terraform {
required_providers { aws = { source = "hashicorp/aws", version = "~> 5.0" } }
}
provider "aws" { region = var.region }
variable "region" { default = "ap-south-1" }
module "vpc" {
source = "terraform-aws-modules/vpc/aws"
version = "~> 5.0"
name = "course-vpc"
cidr = "10.0.0.0/16"
azs = ["ap-south-1a", "ap-south-1b"]
public_subnets = ["10.0.1.0/24", "10.0.2.0/24"]
private_subnets = ["10.0.11.0/24", "10.0.12.0/24"]
}
SECTION 04Weekly study tracker and capstone plan
Use these templates to follow a cloud course week by week:
Week Topic Lab done Notes written Cleaned up
1 Cloud basics, account safety [ ] [ ] [ ]
2 IAM [ ] [ ] [ ]
3 Networking [ ] [ ] [ ]
4 Compute [ ] [ ] [ ]
5 Load balancing, scaling [ ] [ ] [ ]
6 Storage [ ] [ ] [ ]
7 Databases [ ] [ ] [ ]
8 Monitoring [ ] [ ] [ ]
9 Security and cost [ ] [ ] [ ]
10-11 Terraform [ ] [ ] [ ]
12 Capstone [ ] [ ] [ ]
Capstone: highly available web application
- VPC with public and private subnets in two zones (Terraform)
- Load balancer + auto scaling web tier
- Private RDS database with backups
- S3 bucket for static files with lifecycle rules
- CloudWatch alarms and a dashboard
- Encryption, least-privilege IAM, budget alert
- Architecture diagram, README, teardown command
Each week:
Attend classes and take notes
Repeat the lab on your own without notes
Write five interview-style questions for the topic and answer them
Clean up resources and check the billing page
Push code and notes to Git
SECTION 05Tips for following a cloud course week by week
These habits help you keep pace and retain what you learn:
- Repeat every lab alone — doing it without notes builds real skill.
- Clean up after each lab — check billing weekly.
- Draw diagrams — one per week clarifies architecture.
- Do not rush IAM and networking — later weeks depend on them.
- Start the capstone early — plan it from Week 6.
SECTION 06Interview Q&A — cloud course topics
Q1Why should you not use the root account daily?
It has unlimited access; use IAM users or roles with least privilege and protect the root account with MFA.
Q2What is the difference between a public and a private subnet?
A public subnet routes to an internet gateway; a private subnet does not, and reaches the internet only through a NAT gateway if needed.
Q3How does auto scaling improve availability?
It replaces unhealthy instances and adjusts capacity to demand, keeping the application running across zones.
Q4What is an S3 lifecycle rule?
A rule that moves objects to cheaper storage classes or deletes them after a set time, reducing cost.
Q5Why manage infrastructure with Terraform?
It makes infrastructure repeatable, reviewable and version-controlled, reducing manual errors.
SECTION 07Test yourself — cloud course topics quiz
Five questions. No sign-up.
0 / 5Pick an answer to see why it is right or wrong.
SECTION 08Frequently asked questions
How long is a typical cloud computing course?
Many run for a few months, but length varies by provider and depth. Ask for the current schedule and weekly hours.
What is taught first in a cloud course?
Usually cloud concepts, account safety, IAM and networking, because every later module depends on them.
Does a cloud course include Terraform?
Many do, often in later weeks. Check the official syllabus to confirm infrastructure as code is included.
How many hours per week should I study?
Plan for your class hours plus at least as much self-practice, so you can repeat labs and write notes.
What is the capstone in a cloud course?
A final project that combines networking, compute, storage, databases, monitoring and Terraform into one documented architecture.
SECTION 09Related reads
Classroom & online · Noida
Follow a structured AWS cloud course
Our AWS Training Course moves from cloud foundations to IAM, networking, compute, storage, monitoring and Terraform, ending with a capstone project.
Talk to a counsellor for current fees- Weekly hands-on labs
- Terraform module
- Capstone project
- Weekday & weekend batches