🖼️ See the drawing + lab 🏠 Course home 🌿 Branch on GitHub ✏️ View source

🖼️ आकृती आणि labThe drawing + lab पूर्ण पानावर उघडा ↗Open full page ↗

🚪 धडा 01 — NAT का: शाळेचे फाटक

📍 तुम्ही इथे आहात: 8 पैकी धडा 01 · पुढे: lesson-02-how-pat-works

📦 या ब्रँचमध्ये काय आहे

हा संपूर्ण कोर्स एकच प्रश्न सोडवतो: private subnet मधील servers ना internet पर्यंत पोहोचायचे असते (updates, package downloads, partner APIs), पण internet ला त्यांच्यापर्यंत कधीही पोहोचता येता कामा नये. याचे उत्तर म्हणजे असे फाटक जे फेऱ्यांना बाहेर जाऊ देते आणि उत्तरांना परत येऊ देते, बाकी काहीही नाही: NAT (Network Address Translation). संपूर्ण कोर्सभर तुम्ही वापरणार असलेल्या खऱ्या files:

nat/gateway.py — फाटक आणि त्याची नोंदवही: शुद्ध Python मध्ये port address translation चे शिकवण्यासाठीचे model (66 ओळी)
nat/demo.py — प्रत्येक धडा, प्रत्यक्ष चालवून (python3 nat/demo.py <section>; sections: why pat kinds peraz eip costs alternatives troubleshoot)
nat/test_nat.py — फाटकाच्या नियमांवरच्या 8 तपासण्या
demo-output.txt — संपूर्ण demo नीट चालल्यावर काय छापले जाते

🎒 सुरू करण्याआधी: तुम्हाला फक्त Python 3 लागते, बाकी काही नाही — AWS account नको, pip install नको. gateway.py हे शिकवण्यासाठीचे model आहे, router नाही: ते AWS NAT gateway documentation मधील आकडे पाळते (प्रत्येक IP ला प्रत्येक destination साठी 55,000 connections, 350-second idle timeout), पण खरे packets हलवत नाही. त्यातल्या किमती उदाहरण किमती आहेत (us-east-1) — नेहमी AWS pricing page तपासा. खऱ्या account वर अशी खूण असलेल्या commands ना AWS CLI आणि credentials लागतात, आणि NAT gateway अस्तित्वात असेपर्यंत दर तासाला पैसे लागतात.

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

एका शाळेला एक private wing आहे 🏫. आतल्या खोल्यांमध्ये private बाक क्रमांक आहेत — "खोली 48 मधील बाक 25". शाळेबाहेर या क्रमांकांना काहीच अर्थ नाही. गावातले दुकान "बाक 25" ला पत्र पाठवू शकत नाही.

म्हणून बाहेर जाणारी प्रत्येक फेरी शाळेच्या फाटकातून जाते 🚪. फाटकावर एक रखवालदार उभा असतो, त्याच्याकडे एक नोंदवही असते 📒:

एक विद्यार्थिनी दुकानात जाते. रखवालदार नोंदवहीत लिहितो: "बाक 25 वरची विद्यार्थिनी दुकानात गेली". तिचे पत्र शाळेचा पत्ता घेऊन बाहेर पडते.
दुकान शाळेच्या पत्त्यावर उत्तर लिहिते. रखवालदार नोंदवहीत ती ओळ शोधतो आणि उत्तर बाक 25 पर्यंत पोहोचवतो.
एक अनोळखी माणूस दार ठोठावतो आणि म्हणतो "मला बाक 25 कडे जाऊ द्या". रखवालदार नोंदवहीत पाहतो. आतल्या कोणीही या अनोळखी माणसाला बोलावलेले नाही. दार बंदच राहते.

बाहेर जाणे: हो. उत्तरे परत येणे: हो. अनोळखी लोकांनी आत येणे: कधीच नाही. हेच NAT.

🗺️ आकृती

flowchart LR
    desk["🪑 private desk<br/>10.20.48.25:50001"]
    gate["🚪 NAT gateway<br/>public IP 13.232.10.20<br/>📒 register"]
    pypi["🌐 pypi.org<br/>151.101.0.223:443"]
    stranger["🕵️ stranger<br/>198.51.100.9"]
    desk -->|"1 trip out"| gate
    gate -->|"2 leaves as 13.232.10.20:1024"| pypi
    pypi -->|"3 answer back → row found"| gate
    gate -->|"4 handed to the desk"| desk
    stranger -.->|"5 knocks → no row"| drop["🚫 dropped"]

🗺️ काढलेली आकृती + एक lab: https://school-edh.pages.dev/nat/lesson-diagrams.html#l01

❓ काय

Private address — private ranges मधील IPv4 address (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). VPC सहसा हेच वापरते, जसे 10.20.0.0/16. Internet त्यांच्याकडे route करत नाही, त्यामुळे उत्तराला स्वतःहून परतीचा मार्ग सापडत नाही.
Private subnet — असे subnet ज्याच्या route table मध्ये internet gateway कडे जाणारा route नसतो. Internet वरचे काहीही त्याच्यापर्यंत थेट पोहोचू शकत नाही.
NAT (Network Address Translation) — बाहेर जाताना packet चा source address बदलणे (private बाक → फाटकाचा public address), ते लक्षात ठेवणे, आणि परत येताना उत्तर पुन्हा बदलणे.
NAT gateway — AWS चे managed फाटक. Public NAT gateway public subnet मध्ये बसतो, त्याला Elastic IP असतो, आणि private subnets च्या route tables 0.0.0.0/0 त्याच्याकडे पाठवतात. (Private NAT gateway सुद्धा असतो — धडा 07.)
फक्त outbound — connection आतून सुरू व्हायलाच हवे. त्याची उत्तरे परत येतात. बाहेरून सुरू झालेल्या connection ला नोंदवहीत ओळ सापडत नाही आणि ते drop होते.
Egress — तुमच्या network मधून बाहेर जाणारा traffic. "Internet egress" हा या कोर्सचा विषय आहे.

🤔 का

कारण databases, app servers आणि batch jobs यांची जागा private subnets मध्येच आहे: internet वरच्या कोणालाही त्यांच्याशी connection उघडता येऊ नये. पण त्याच servers ना OS patches आणावे लागतात, pypi.org किंवा npm वरून packages घ्यावे लागतात, आणि payment किंवा SMS APIs call कराव्या लागतात. "फक्त updates download करण्यासाठी" त्यांना public IPs देऊन public subnet मध्ये ठेवले तर दार दोन्ही बाजूंनी उघडते. NAT ते फक्त एकाच बाजूने उघडतो.

🔧 कसे (या repo मध्ये)

nat/demo.py मधील why() एक public IP असलेले एक फाटक तयार करते, NatGateway.send() ने एका बाकाला pypi.org कडे बाहेर पाठवते, आणि मग NatGateway.reply() ने एका अनोळखी माणसाला ठोठावू देते. nat/gateway.py मध्ये send() हे self.table (नोंदवही) मध्ये एक ओळ लिहिते आणि public address व port परत देते; reply() ती ओळ शोधते आणि private बाक परत देते, किंवा drop मोजून None परत देते.

🧪 करून पाहा

python3 nat/demo.py why
python3 - <<'EOF'
import sys; sys.path.insert(0, "nat"); from gateway import NatGateway
PYPI = ("151.101.0.223", 443, "tcp")
STRANGER = ("198.51.100.9", 443, "tcp")
g = NatGateway("nat-a", ["13.232.10.20"])
ip, port = g.send(("10.20.48.25", 50001), PYPI)
print("the desk leaves as:", ip, port)
print("pypi answers:", g.reply(ip, port, PYPI))
print("stranger on the same port:", g.reply(ip, port, STRANGER))
print("stranger on port 8080:", g.reply(ip, 8080, STRANGER))
print("rows:", len(g.table), "dropped:", g.dropped)
EOF
python3 nat/test_nat.py

✅ तपासा — तुम्हाला काय दिसायला हवे

why हे app 10.20.48.25:50001 → pypi.org leaves as 13.232.10.20:1024 आणि a stranger knocks on 13.232.10.20:2222 → dropped — nobody inside asked छापते. तुमचा snippet हे छापतो:

the desk leaves as: 13.232.10.20 1024
pypi answers: ('10.20.48.25', 50001)
stranger on the same port: None
stranger on port 8080: None
rows: 1 dropped: 2

तिसरी ओळ पाहा: अनोळखी माणसाने बाक वापरत असलेल्या त्याच port वर ठोठावले, आणि तरीही तो drop झाला. नोंदवहीतील ओळ सांगते "port 1024, pypi.org साठी". इतर कोणाकडून आलेले उत्तर जुळत नाही. Tests 8/8 passed ने संपतात.

🏁 तुम्ही आत्ताच काय सिद्ध केले

फाटकामागचा बाक बाहेर जाऊन आपले उत्तर परत मिळवू शकतो — आणि अनोळखी माणूस आतल्या दिशेने संवाद सुरू करू शकत नाही, वापरात असलेला port अंदाजाने ओळखला तरीसुद्धा नाही.

⚠️ नेहमीच्या चुका

फक्त updates download करता याव्यात म्हणून servers ना public IPs देऊन public subnet मध्ये ठेवणे
NAT म्हणजे तुम्ही नियम लिहिता असा firewall आहे असे समजणे — तो फक्त उत्तरे परत येऊ देतो; servers वर security groups वापरतच राहा
NAT gateway private subnet मध्ये ठेवणे — public NAT gateway public subnet मध्येच (internet gateway कडे route असलेल्या) बसायला हवा
private route table मधील 0.0.0.0/0 → nat-… route विसरणे — फाटक अस्तित्वात आहे, पण त्याच्याकडे कोणी जातच नाही

🏭 प्रत्यक्ष वापरात

खऱ्या account वर (AWS CLI आणि credentials लागतात; NAT gateway तयार झाल्याच्या क्षणापासून दर तासाला bill लागते):

aws ec2 allocate-address --domain vpc                        # the gate's fixed address → eipalloc-…
aws ec2 create-nat-gateway --subnet-id subnet-public-a --allocation-id eipalloc-0abc --connectivity-type public
aws ec2 create-route --route-table-id rtb-private-a --destination-cidr-block 0.0.0.0/0 --nat-gateway-id nat-0abc
aws ec2 describe-nat-gateways --query 'NatGateways[].[NatGatewayId,State,SubnetId,ConnectivityType]' --output table

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: "internet ला सेवा न देणाऱ्या सगळ्यासाठी private subnets, आणि egress NAT मधून" हीच AWS network ची default रचना आहे. पुढचे सात धडे ते फाटक नीट चालवण्याबद्दल आहेत: ते कसे लक्षात ठेवते, ते कुठे ठेवायचे, त्याचा खर्च किती आणि ते कसे बिघडते.

⏭️ पुढे

एक फाटक, एक public address, शेकडो बाक. उत्तर कोणत्या बाकाचे आहे हे रखवालदाराला कसे कळते? फाटक कसे लक्षात ठेवते (PAT) — नोंदवही, ओळ-ओळ करून.

git checkout lesson-02-how-pat-works

🚪 Lesson 01 — Why NAT: the school gate

📍 You are here: Lesson 01 of 8 · Next: lesson-02-how-pat-works

📦 What's in this branch

The one problem this whole course solves: servers in a private subnet need to reach the internet (updates, package downloads, partner APIs), but the internet must never be able to reach them. The answer is a gate that lets trips go out and answers come back, and nothing else: NAT (Network Address Translation). Real files you will use all the way through:

nat/gateway.py — the gate and its register: a teaching model of port address translation in pure Python (66 lines)
nat/demo.py — every lesson, live (python3 nat/demo.py <section>; sections: why pat kinds peraz eip costs alternatives troubleshoot)
nat/test_nat.py — 8 checks on the gate's rules
demo-output.txt — what a healthy run of the whole demo prints

🎒 Before you start: you need Python 3 and nothing else — no AWS account, no pip install. gateway.py is a teaching model, not a router: it follows the numbers in the AWS NAT gateway documentation (55,000 connections per destination per IP, a 350-second idle timeout), but it does not move real packets. Prices in it are example prices (us-east-1) — always check the AWS pricing page. Commands marked on a real account need the AWS CLI and credentials, and a NAT gateway costs money every hour it exists.

🧒 Explain like I'm 5

A school has a private wing 🏫. The rooms inside have private desk numbers — "desk 25 in room 48". Those numbers mean nothing outside the school. A shop in town cannot post a letter to "desk 25".

So every trip out goes through the school gate 🚪. At the gate stands a guard with a register book 📒:

A pupil goes out to the shop. The guard writes in the register: "pupil from desk 25 went to the shop". The pupil's letter leaves with the school's address on it.
The shop writes back to the school's address. The guard finds the row in the register and walks the answer to desk 25.
A stranger knocks and says "let me in to desk 25". The guard looks in the register. Nobody inside asked for this stranger. The door stays shut.

Out: yes. Answers back: yes. Strangers walking in: never. That is NAT.

🗺️ Diagram

flowchart LR
    desk["🪑 private desk<br/>10.20.48.25:50001"]
    gate["🚪 NAT gateway<br/>public IP 13.232.10.20<br/>📒 register"]
    pypi["🌐 pypi.org<br/>151.101.0.223:443"]
    stranger["🕵️ stranger<br/>198.51.100.9"]
    desk -->|"1 trip out"| gate
    gate -->|"2 leaves as 13.232.10.20:1024"| pypi
    pypi -->|"3 answer back → row found"| gate
    gate -->|"4 handed to the desk"| desk
    stranger -.->|"5 knocks → no row"| drop["🚫 dropped"]

🗺️ Drawn version + a lab: https://school-edh.pages.dev/nat/lesson-diagrams.html#l01

❓ What

Private address — an IPv4 address from the private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16). A VPC usually uses them, such as 10.20.0.0/16. The internet does not route to them, so an answer cannot find its way back on its own.
Private subnet — a subnet whose route table has no route to an internet gateway. Nothing on the internet can reach it directly.
NAT (Network Address Translation) — rewriting the source address of a packet on its way out (private desk → the gate's public address), remembering it, and rewriting the answer on its way back.
NAT gateway — AWS's managed gate. A public NAT gateway sits in a public subnet, has an Elastic IP, and the private subnets' route tables send 0.0.0.0/0 to it. (There is also a private NAT gateway — lesson 07.)
Outbound only — a connection must start inside. Answers to it come back. A connection that starts outside finds no row in the register and is dropped.
Egress — traffic leaving your network. "Internet egress" is this course's subject.

🤔 Why

Because private subnets are where databases, app servers and batch jobs belong: nothing on the internet should be able to open a connection to them. But those same servers still need to fetch OS patches, pull packages from pypi.org or npm, and call payment or SMS APIs. Putting them in a public subnet with public IPs "just to download updates" opens the door both ways. NAT opens it one way only.

🔧 How (in this repo)

why() in nat/demo.py builds one gate with one public IP, sends one desk out to pypi.org with NatGateway.send(), then lets a stranger knock with NatGateway.reply(). In nat/gateway.py, send() writes a row in self.table (the register) and returns the public address and port; reply() looks the row up and returns the private desk, or counts a drop and returns None.

🧪 Try it

python3 nat/demo.py why
python3 - <<'EOF'
import sys; sys.path.insert(0, "nat"); from gateway import NatGateway
PYPI = ("151.101.0.223", 443, "tcp")
STRANGER = ("198.51.100.9", 443, "tcp")
g = NatGateway("nat-a", ["13.232.10.20"])
ip, port = g.send(("10.20.48.25", 50001), PYPI)
print("the desk leaves as:", ip, port)
print("pypi answers:", g.reply(ip, port, PYPI))
print("stranger on the same port:", g.reply(ip, port, STRANGER))
print("stranger on port 8080:", g.reply(ip, 8080, STRANGER))
print("rows:", len(g.table), "dropped:", g.dropped)
EOF
python3 nat/test_nat.py

✅ Verify — what you should see

why prints app 10.20.48.25:50001 → pypi.org leaves as 13.232.10.20:1024 and a stranger knocks on 13.232.10.20:2222 → dropped — nobody inside asked. Your snippet prints:

the desk leaves as: 13.232.10.20 1024
pypi answers: ('10.20.48.25', 50001)
stranger on the same port: None
stranger on port 8080: None
rows: 1 dropped: 2

Look at the third line: the stranger knocked on the very port the desk is using, and was still dropped. The register row says "port 1024, for pypi.org". An answer from anyone else does not match. The tests end with 8/8 passed.

🏁 What you just proved

A desk behind the gate can go out and get its answer back — and a stranger cannot start a conversation in, not even by guessing a port that is in use.

⚠️ Common mistakes

putting servers in a public subnet with public IPs only so they can download updates
thinking NAT is a firewall with rules you write — it only lets answers back; still use security groups on the servers
putting the NAT gateway in a private subnet — a public NAT gateway must sit in a public subnet (a route to an internet gateway)
forgetting the private route table's 0.0.0.0/0 → nat-… route — the gate exists, but nobody walks to it

🏭 In production

On a real account (needs the AWS CLI and credentials; the NAT gateway bills every hour from the moment it is created):

aws ec2 allocate-address --domain vpc                        # the gate's fixed address → eipalloc-…
aws ec2 create-nat-gateway --subnet-id subnet-public-a --allocation-id eipalloc-0abc --connectivity-type public
aws ec2 create-route --route-table-id rtb-private-a --destination-cidr-block 0.0.0.0/0 --nat-gateway-id nat-0abc
aws ec2 describe-nat-gateways --query 'NatGateways[].[NatGatewayId,State,SubnetId,ConnectivityType]' --output table

🏭 Why this matters in production: "private subnets for everything that does not serve the internet, egress through NAT" is the default AWS network design. The next seven lessons are about running that gate well: how it remembers, where to put it, what it costs and how it breaks.

⏭️ Next

One gate, one public address, hundreds of desks. How does the guard know which desk an answer belongs to? How the gate remembers (PAT) — the register, row by row.

git checkout lesson-02-how-pat-works

← Course homeall lessons Next →how pat works

This page is the lesson's README from the lesson-01-why-nat branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.