The Cloud Computing Picture Book
Cloud provider ComputeVMs · containers Storageobjects · disks NetworkVPC · DNS · CDN Pay for what you useno hardware to buy · scale in minutes · you own the security of what you put therelike electricity: always on, metered, shared
PLATE 0 — Rent building blocks by the hour. Assemble them with code.
A picture book for grown-ups · with commands

Cloud Computing, Explained

Nine spreads on how the cloud works and how to use it: compute, storage, networking, identity, databases, serverless, cost and security. Examples use AWS with notes for Azure and GCP.

Say it like a pro

"Infrastructure as code in private subnets across zones, least-privilege IAM roles, managed databases, autoscaling compute, and budgets with alerts."

Use the tabs or the ← → keys. Cloud services cost money. Set a budget alert first.

On-prem IaaS PaaS SaaS application · data · you (rows 1–2 shaded = yours) runtime OS servers data centre red = you manage · grey = provider Examples IaaS: EC2, Azure VMs, Compute Engine · PaaS: App Service, Cloud Run, Elastic Beanstalk SaaS: Gmail, Salesforce · FaaS (serverless functions): Lambda, Azure Functions
PLATE 1 — The higher up the stack, the less you manage and the less you control.
Chapter 1 · Cloud models

IaaS, PaaS, SaaS, and who is responsible for what

region
a geographic area (us-east-1, eu-west-2) with several data centres
availability zone
one or more isolated data centres inside a region; spread across 2–3 for resilience
public / private / hybrid / multi
shared provider / dedicated / on-prem + cloud / more than one provider
shared responsibility
provider secures the cloud itself; you secure your data, identities, configuration
IdeaAWSAzureGCP
VMEC2Virtual MachinesCompute Engine
Object storageS3Blob StorageCloud Storage
Managed SQLRDS / AuroraAzure SQL / PGCloud SQL
FunctionsLambdaFunctionsCloud Functions
KubernetesEKSAKSGKE
IdentityIAMEntra ID + RBACIAM
$ aws --version ; aws configure sso          # prefer SSO / short-lived credentials
$ aws sts get-caller-identity               # who am I, which account?
$ aws ec2 describe-regions --query 'Regions[].RegionName'
Say it like a pro

"Two or three AZs in one region, and we own IAM, data and configuration under the shared responsibility model."

VMsEC2full control ContainersECS · EKS · Cloud Runportable ServerlessLambdano servers to run more control ← → less operations work Autoscaling group min 3 · max 10 · scale on CPU 60% or request count · spread across zones pricing: on-demand · reserved/savings plans (1–3 yr, ~30–70% off) · spot (cheap, can be reclaimed) right-size: most instances are bigger than they need to be
PLATE 2 — Pick the lowest-effort compute that meets your needs.
Chapter 2 · Compute

VMs, containers, and functions

# launch a small VM (AWS CLI)
$ aws ec2 run-instances --image-id ami-0abcdef1234567890 --instance-type t3.micro \
    --key-name mykey --security-group-ids sg-0123 --subnet-id subnet-0abc \
    --tag-specifications 'ResourceType=instance,Tags=[{Key=Name,Value=web-1}]'
$ aws ec2 describe-instances --filters Name=tag:Name,Values=web-1 \
    --query 'Reservations[].Instances[].[InstanceId,State.Name,PublicIpAddress]'
$ aws ec2 terminate-instances --instance-ids i-0123456789abcdef0   # stop paying
# a serverless function (Python, AWS Lambda)
import json
def handler(event, context):
    name = (event.get("queryStringParameters") or {}).get("name", "world")
    return {"statusCode": 200, "body": json.dumps({"hello": name})}
AMI / image
the template a VM boots from
user data
a script run on first boot to install and start your app
cold start
delay when a function starts from idle
serverless fits
spiky, event-driven, short jobs; costly for steady heavy load
Say it like a pro

"Containers on a managed service for the web tier, Lambda for events, spot capacity for batch jobs."

ObjectS3 · bucket/keyfiles, backups, mediavia HTTP API BlockEBS · a virtual diskdatabases, OSone VM at a time FileEFS · NFS/SMB sharemany VMs at onceshared content S3 storage classes: pay less for colder data Standard Infrequent Glacier Deep archive lifecycle rules move data down automatically after N days Durability ≠ availability ≠ backup S3: 11 nines durable, but you can still delete or overwrite turn on versioning, MFA-delete or object lock, and cross-region copies
PLATE 3 — Objects for files, blocks for disks, file shares for sharing.
Chapter 3 · Storage

Buckets, disks, and shares

$ aws s3 mb s3://my-unique-bucket-name
$ aws s3 cp photo.jpg s3://my-unique-bucket-name/uploads/
$ aws s3 sync ./site s3://my-unique-bucket-name --delete
$ aws s3 ls s3://my-unique-bucket-name --recursive --human-readable
$ aws s3api put-bucket-versioning --bucket my-unique-bucket-name \
    --versioning-configuration Status=Enabled
$ aws s3api put-public-access-block --bucket my-unique-bucket-name \
    --public-access-block-configuration BlockPublicAcls=true,IgnorePublicAcls=true,BlockPublicPolicy=true,RestrictPublicBuckets=true
$ aws s3 presign s3://my-unique-bucket-name/uploads/photo.jpg --expires-in 600   # temporary link
  • Block public access by default. Most cloud data leaks are open buckets.
  • Encrypt at rest (default on) with provider or customer-managed keys.
  • Let clients upload directly with pre-signed URLs instead of through your server.
  • Lifecycle + versioning keep costs low and recover from mistakes.
Say it like a pro

"Private buckets with versioning and lifecycle rules, pre-signed URLs for access, and a CDN in front for public assets."

Internet IGW VPC 10.0.0.0/16 public subnet · AZ-aALBNAT public subnet · AZ-bALB private subnet · AZ-aapp private subnet · AZ-bapp isolated subnets · no route to the internetDB primaryDB standby
PLATE 4 — Only the load balancer faces the internet. Everything else hides in private layers.
Chapter 4 · Cloud networking

Your private network in the cloud (VPC)

VPC / VNet
your isolated virtual network with an IP range
subnet
a slice of that range inside one AZ; public = has a route to an internet gateway
NAT gateway
lets private instances call out (updates, APIs) without being reachable
security group
stateful firewall per instance; allow only the ports needed, from specific sources
NACL
stateless subnet-level filter, a second layer
peering / Transit Gateway / VPN / Direct Connect
connect VPCs and your office or data centre
Route 53 / DNS · CloudFront / CDN
names and edge caching
$ aws ec2 create-security-group --group-name web-sg --description "web" --vpc-id vpc-0abc
$ aws ec2 authorize-security-group-ingress --group-id sg-0123 --protocol tcp --port 443 --cidr 0.0.0.0/0
$ aws ec2 authorize-security-group-ingress --group-id sg-app --protocol tcp --port 3000 --source-group sg-alb
  # app only accepts traffic from the load balancer's group, not the world
$ aws ec2 describe-vpcs ; aws ec2 describe-route-tables
Say it like a pro

"Public subnets hold the load balancer, apps and databases sit in private subnets, and security groups reference each other."

User Role PolicyAllow s3:GetObjecton bucket/reports/* assumehas The rules 1 · everything is denied unless a policy allows it 2 · an explicit Deny always beats any Allow 3 · prefer roles (temporary credentials) over long-lived access keys 4 · VMs and functions get an instance role. No keys on disk. Never use the root account for daily work · commit keys to git · give "*" permissions turn on MFA for root and every human user
PLATE 5 — Identity is the real perimeter in the cloud.
Chapter 5 · Identity & access (IAM)

Least privilege, roles, and no long-lived keys

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Action": ["s3:GetObject", "s3:PutObject"],
    "Resource": "arn:aws:s3:::my-unique-bucket-name/uploads/*"
  }]
}
$ aws iam create-policy --policy-name app-uploads --policy-document file://policy.json
$ aws iam create-role --role-name app-role --assume-role-policy-document file://trust.json
$ aws iam attach-role-policy --role-name app-role --policy-arn arn:aws:iam::123456789012:policy/app-uploads
$ aws iam get-account-authorization-details > iam.json     # audit who can do what
$ aws iam generate-credential-report
principal
who: user, role, service
ARN
a resource's unique name
SSO / federation
log in with your company identity; short-lived sessions
tools
IAM Access Analyzer finds unintended public or cross-account access
Say it like a pro

"Workloads assume scoped roles, humans use SSO with MFA, and Access Analyzer reviews what's exposed."

Browser CDN + S3static front end API Gateway Lambda DynamoDB SQS Let the provider run the undifferentiated stuff managed DB (RDS/Aurora): backups, patching, Multi-AZ failover, read replicas managed queues, caches (ElastiCache), search, identity (Cognito), email (SES) Trade-offs + less ops, built-in scaling and HA · − cost at scale, lock-in, less control keep portability via standard interfaces (SQL, containers, S3 API) where it matters
PLATE 6 — Stitch managed services together instead of running your own.
Chapter 6 · Managed databases & serverless

Rent the database, skip the servers

$ aws rds create-db-instance --db-instance-identifier shop-db --engine postgres \
    --db-instance-class db.t4g.micro --allocated-storage 20 \
    --master-username app --manage-master-user-password \
    --multi-az --storage-encrypted --backup-retention-period 7 \
    --no-publicly-accessible --db-subnet-group-name private-subnets \
    --vpc-security-group-ids sg-db
$ aws rds describe-db-instances --query 'DBInstances[].[DBInstanceIdentifier,DBInstanceStatus,Endpoint.Address]'
$ aws rds create-db-snapshot --db-instance-identifier shop-db --db-snapshot-identifier before-upgrade
// DynamoDB: key-value at any scale (Node SDK v3)
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, PutCommand, GetCommand } from "@aws-sdk/lib-dynamodb";
const db = DynamoDBDocumentClient.from(new DynamoDBClient({}));
await db.send(new PutCommand({ TableName: "Orders", Item: { pk: "USER#42", sk: "ORDER#1001", total: 2400 } }));
const { Item } = await db.send(new GetCommand({ TableName: "Orders", Key: { pk: "USER#42", sk: "ORDER#1001" } }));
Multi-AZ
a standby in another zone; automatic failover
read replica
scale reads; may lag
secrets
Secrets Manager / Parameter Store, not environment files in git
Say it like a pro

"Managed Postgres in private subnets with Multi-AZ, encryption and backups, secrets from Secrets Manager."

code (git) plan review apply Why not click in the console? repeatable · reviewable in a pull request · versioned · recreate whole environments consoles drift: "who changed that setting?" has no answer state file = what exists · store it remotely with locking Tools Terraform / OpenTofu (any cloud) · Pulumi (real languages) CloudFormation / CDK (AWS) · Bicep (Azure) · Ansible (configuring servers) CI runs plan on PRs and apply on merge
PLATE 7 — Treat infrastructure like software: reviewed, tested, repeatable.
Chapter 7 · Infrastructure as code

Describe it once, create it anywhere

# main.tf (Terraform): a private, versioned, encrypted bucket
terraform {
  required_providers { aws = { source = "hashicorp/aws", version = "~> 5.0" } }
  backend "s3" { bucket = "my-tf-state" key = "app/terraform.tfstate" region = "eu-west-2" dynamodb_table = "tf-locks" }
}
provider "aws" { region = "eu-west-2" }

resource "aws_s3_bucket" "uploads" { bucket = "my-unique-bucket-name" }
resource "aws_s3_bucket_versioning" "uploads" {
  bucket = aws_s3_bucket.uploads.id
  versioning_configuration { status = "Enabled" }
}
resource "aws_s3_bucket_public_access_block" "uploads" {
  bucket = aws_s3_bucket.uploads.id
  block_public_acls = true  block_public_policy = true
  ignore_public_acls = true restrict_public_buckets = true
}
$ terraform init
$ terraform fmt && terraform validate
$ terraform plan -out tf.plan        # read this carefully
$ terraform apply tf.plan
$ terraform destroy                  # tear down a lab to stop charges
Say it like a pro

"All infrastructure in Terraform with remote locked state, plan in the pull request, apply from CI."

compute storage egress managed Where the bill comes from Cut it ☐ turn off idle dev/test at night ☐ right-size instances ☐ savings plans / reserved ☐ spot for batch work ☐ lifecycle rules, delete orphans ☐ keep traffic in-region, use CDN Set a budget alert on day one forgotten GPUs, NAT gateways, load balancers and public IPs keep billing tag every resource with owner + project so you can see who spends what leaked keys are often used to mine crypto in minutes
PLATE 8 — The cloud is cheap to start and expensive to forget.
Chapter 8 · Cost & operations

Know what you're paying for

$ aws budgets create-budget --account-id 123456789012 --budget file://budget.json \
    --notifications-with-subscribers file://notify.json        # email at 80% and 100%
$ aws ce get-cost-and-usage --time-period Start=2026-10-01,End=2026-10-30 \
    --granularity MONTHLY --metrics UnblendedCost --group-by Type=DIMENSION,Key=SERVICE
$ aws ec2 describe-volumes --filters Name=status,Values=available      # orphaned disks costing money
$ aws ec2 describe-addresses --query 'Addresses[?AssociationId==null]' # unused elastic IPs
egress
data leaving the provider or crossing regions is the surprise line item
tags
owner, project, env: enforce them in IaC
free tier
great for learning; know its limits and expiry
CloudWatch / Azure Monitor / Cloud Monitoring
metrics, logs and alarms for ops
Say it like a pro

"Budgets with alerts, mandatory tags, right-sized instances, and non-prod shut down out of hours."

Your workload Operations Security Reliability Performance Cost Sustainability Security checklist MFA + SSO · private subnets · encryption · CloudTrail logging on · GuardDuty alerts patch images · scan IaC and containers · backups tested · separate accounts for prod/dev
PLATE 9 — Good cloud design balances six concerns. Skipping one shows up later as an outage or a bill.
Chapter 9 · Secure & reliable by design

The habits that keep a cloud account healthy

  1. Separate accounts (or subscriptions) for prod, staging, and dev under one organization with guardrails (SCPs/policies).
  2. Log everything: CloudTrail (API calls), VPC flow logs, load balancer logs, to a protected log account.
  3. Detect: GuardDuty / Defender for Cloud / Security Command Center, and Config rules for drift.
  4. Encrypt and rotate: KMS keys, short-lived credentials, secrets in a manager.
  5. Design for failure: multi-AZ, health checks, backups, runbooks, game days.
$ aws cloudtrail describe-trails ; aws guardduty list-detectors
$ aws configservice describe-compliance-by-config-rule
$ aws iam get-account-summary | grep -i mfa
$ npx checkov -d .            # scan Terraform for misconfigurations
$ prowler aws                  # security audit of your own account
certifications
AWS Cloud Practitioner → Solutions Architect Associate; Azure AZ-900 → AZ-104; Google Associate Cloud Engineer
practise
free-tier labs, then rebuild the same small app with Terraform; always run destroy after
Say it like a pro

"Multi-account landing zone, everything logged and monitored, IaC-enforced guardrails, and tested recovery."