Tutorials
Longer lessons, written for beginners in plain words, one idea at a time.
Series · DevOps Networking — 16 parts
- Lesson 01 — What Networking Means in DevOps, and IP Addresses
Networking from zero: why machines need to reach each other, who hands out IP addresses, how the world ran out of them, and what IPv6 fixes.
- Lesson 02 — Ports
How ports identify which program on a machine a request is for, who claims them, the permission rule for low numbers, and why every request carries a source port too.
- Lesson 03 — Network Models and Layers
What a network layer actually is, where the official numbers and names come from, and how encapsulation nests the message like envelopes inside envelopes.
- Lesson 04 — DNS
How DNS turns names into numbers by walking a chain of delegation, why caching and TTL exist, and who actually runs, sells, and rents out domain names.
- Lesson 05 — DHCP
How DHCP automatically hands a joining computer its number, DNS runner, and way out through a four-line conversation, and why the number is a lease rather than a gift.
- Lesson 06 — MAC Addresses and ARP
Why every device carries a second, factory-burned address, how the Layer 2 envelope and ARP handle the final metres of delivery, and why the MAC envelope is rewritten at every hop while the IP envelope crosses the world untouched.
- Lesson 07 — Routing
Since Lesson 01, one phrase has carried the whole story: junctions read the address and "pick a direction." The MAC lesson sharpened it — the IP envelope crosses the world untouched while each hop reads 140.82.121.4 and decides which way to pass it.
- Lesson 08 — Subnets and CIDR
Three lessons have leaned on the same vague phrase: the DHCP bundle describing "which addresses count as the house," the laptop's local-or-gateway decision, and routing table lines like 192.168.1.x → house side.
- Lesson 09 — NAT
Lesson 01 promised: "your whole home shares one internet-facing number, and the router does the translation in both directions." The factory-to-pixels story in Lesson 06 flagged the same gap: the reply's journey back into the house skips a step.
- Lesson 10 — TCP vs UDP
From the layers lesson, the message is lines read by different readers:
- Lesson 11 — HTTP and HTTPS
From the layers lesson:
- Lesson 12 — TLS
TLS sits just below Layer 7 .
- Lesson 13 — Firewalls
Firewalls make decisions using the envelope layers already covered:
- Lesson 14 — Troubleshooting Tools
dig asks a DNS runner a question and prints the full answer.
- Lesson 15 — VPN
VPN = Virtual Private Network.
- Lesson 16 — DNSSEC (and the post-quantum wrinkle)
Lesson 04 taught the whole DNS chain: you type github.com, your runner walks root → .com → the owner's computer, and comes back with "github.com is 140.82.121.4." One question was never asked:
Series · DevOps Networking — AWS — 5 parts
- AWS Lesson 01 — What a VPC Is
In Part 1 the project ran on one machine — React, Java, PostgreSQL, all on 10.0.1.10.
- AWS Lesson 02 — Subnets
The VPC claimed 10.0.0.0/16 — about 65,000 private addresses, one big undivided plot.
- AWS Lesson 03 — Public vs Private Subnets
The three project pieces have opposite reachability needs:
- AWS Lesson 04 — Route Tables
From Foundations Lesson 07, a routing table is a list of rules, each "addresses like this → that exit." An AWS route table is exactly that, as something you edit in a form:
- AWS Lesson 05 — Internet Gateway
An internet gateway is the door in a VPC's wall to the public internet.