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

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

📒 धडा 02 — फाटक कसे लक्षात ठेवते (PAT)

📍 तुम्ही इथे आहात: 8 पैकी धडा 02 · मागे: lesson-01-why-nat · पुढे: lesson-03-gateway-vs-instance

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

धडा 01, आणि प्रत्यक्ष नोंदवही: port address translation (PAT). एकच public IP अनेक private बाकांना पुरतो, आणि फाटक देत असलेल्या port वरून तो त्यांना वेगळे ओळखतो. nat/demo.py मधील pat() नोंदवही ओळ-ओळ करून छापते.

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

एकाच वेळी अनेक विद्यार्थिनी एकाच फाटकातून बाहेर जातात. त्यांची सगळी पत्रे एकाच शाळेच्या पत्त्याने बाहेर पडतात. मग कोणते उत्तर कुठे जायचे हे रखवालदाराला कसे कळते?

रखवालदार प्रत्येक फेरीला एक तिकीट क्रमांक 🎟️ देतो आणि तो नोंदवहीत लिहितो:

तिकीट	विद्यार्थिनी	कुठे गेली
1024	बाक 25, खोली 48	पुस्तकांचे दुकान
1025	बाक 7, खोली 64	पुस्तकांचे दुकान
1024	बाक 25, खोली 48	संग्रहालय

उत्तर परत येते आणि त्यावर लिहिलेले असते "शाळेचा पत्ता, तिकीट 1025, पुस्तकांच्या दुकानाकडून". रखवालदार ती ओळ वाचतो आणि ते बाक 7 पर्यंत पोहोचवतो. दोन विद्यार्थिनींचा private खिसा क्रमांक एकच असला तरी चालते — तिकिटे वेगळी असतात, त्यामुळे उत्तरे कधीच एकमेकांत मिसळत नाहीत.

लक्षात घ्या, तिकीट 1024 दोनदा आले आहे. ते चालते: एक फेरी पुस्तकांच्या दुकानात गेली, दुसरी संग्रहालयात. रखवालदार तिकीट आणि उत्तर कोण लिहित आहे हे दोन्ही जुळवतो.

🗺️ आकृती

flowchart LR
    d1["🪑 10.20.48.25:50001"]
    d2["🪑 10.20.64.7:50001"]
    gate["🚪 13.232.10.20<br/>📒 register<br/>1024 ↔ 10.20.48.25:50001 (pypi)<br/>1025 ↔ 10.20.64.7:50001 (pypi)"]
    pypi["🌐 pypi 151.101.0.223:443"]
    d1 -->|"1 out"| gate
    d2 -->|"1 out"| gate
    gate -->|"2 :1024 and :1025"| pypi
    pypi -->|"3 answer to :1025"| gate
    gate -->|"4 row 1025 → 10.20.64.7"| d2

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

❓ काय

Connection पाच गोष्टींनी ओळखले जाते: source IP, source port, destination IP, destination port, protocol (NAT gateway साठी TCP, UDP किंवा ICMP).
PAT (port address translation) — अनेक private addresses एकच public address वापरतात; फाटक source port सुद्धा बदलते, त्यामुळे प्रत्येक connection ला त्या destination साठी वेगळा public IP:port मिळतो.
Translation table (नोंदवही) — model मध्ये प्रत्येक ओळ (public_ip, public_port, destination) ने ओळखली जाते आणि त्यात private (ip, port) व ती शेवटची वापरली गेल्याची वेळ असते.
तोच संवाद, तीच ओळ — त्याच बाकावरून आणि त्याच port वरून त्याच destination कडे जाणारा packet आपली ओळ पुन्हा वापरतो. म्हणूनच TCP connection ला त्याच्या संपूर्ण आयुष्यभर एकच public port राहतो.
Ports प्रत्येक destination साठी वेगळे — public port 1024 एकाच वेळी pypi कडे आणि GitHub कडे वापरात असू शकतो. म्हणूनच AWS ची मर्यादा (धडा 08) प्रत्येक unique destination साठी असते.
परतीचा traffic — उत्तराचा destination IP:port आणि त्याचा source एखाद्या ओळीशी जुळला तरच ते आत घेतले जाते. बाकी सगळे drop होते.

🤔 का

कारण machines पेक्षा public IPv4 addresses खूपच कमी आहेत. PAT मुळे संपूर्ण VPC एकच address (किंवा काही) वापरू शकते, आणि NAT "फक्त outbound" असण्याचे कारणही हीच नोंदवही आहे: ओळ नाही, तर प्रवेश नाही. पुढे तुम्ही "connection reset" किंवा "cannot allocate port" errors debug कराल (धडा 08), तेव्हा तुम्ही हीच नोंदवही debug करत असाल.

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

nat/gateway.py मध्ये send() आधी त्याच src आणि dst ची आधीपासून असलेली ओळ शोधते आणि ती पुन्हा वापरते. ती नसेल, तर त्या IP वर त्या destination कडे आधीच वापरात नसलेला सर्वात लहान मोकळा port (1024 पासून वर) घेते, ओळ लिहिते आणि (public_ip, public_port) परत देते. nat/demo.py मधील pat() तीन connections पाठवते आणि g.table छापते.

🧪 करून पाहा

python3 nat/demo.py pat
python3 - <<'EOF'
import sys; sys.path.insert(0, "nat"); from gateway import NatGateway
GITHUB = ("140.82.112.3", 443, "tcp")
g = NatGateway("nat-a", ["13.232.10.20"])
for desk in ("10.20.48.25", "10.20.64.7", "10.20.80.9"):
    print(desk, "→", g.send((desk, 50001), GITHUB))
print("same desk again →", g.send(("10.20.64.7", 50001), GITHUB), "· rows:", len(g.table))
print("answer on 1026  →", g.reply("13.232.10.20", 1026, GITHUB))
print("answer on 1027  →", g.reply("13.232.10.20", 1027, GITHUB))
EOF

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

pat तीन translations छापते:

   10.20.48.25:50001  → 151.101.0.223:443  written as 13.232.10.20:1024
   10.20.64.7:50001   → 151.101.0.223:443  written as 13.232.10.20:1025
   10.20.48.25:50002  → 140.82.112.3:443   written as 13.232.10.20:1024

मग नोंदवही, आणि answer to 13.232.10.20:1025 from pypi → back to ('10.20.64.7', 50001). तुमचा snippet हे छापतो:

10.20.48.25 → ('13.232.10.20', 1024)
10.20.64.7 → ('13.232.10.20', 1025)
10.20.80.9 → ('13.232.10.20', 1026)
same desk again → ('13.232.10.20', 1025) · rows: 3
answer on 1026  → ('10.20.80.9', 50001)
answer on 1027  → None

तीन बाकांनी एकच private port 50001 वापरला आणि त्यांना तीन वेगवेगळे public ports मिळाले. पुन्हा पाठवल्याने नवी ओळ जोडली गेली नाही. Port 1027 कधी दिलाच गेला नव्हता, म्हणून त्याचे "उत्तर" drop झाले.

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

एकच public IP अनेक बाकांना पुरतो, कारण फाटक ports वाटते आणि प्रत्येक लिहून ठेवते; नोंदवही ही उत्तरांसाठीची पत्त्यांची वही आहे आणि अनोळखी लोकांविरुद्धचे कुलूपही.

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

public port आणि private port एकच असतो असे समजणे — तो फाटक निवडते
एका server वरून होणाऱ्या प्रत्येक connection ला एकच public port मिळेल अशी अपेक्षा — प्रत्येक connection ला स्वतःचा मिळतो
"एक public IP = एका वेळी एकच connection" असे गृहीत धरणे — PAT प्रत्येक destination साठी हजारो देतो
नोंदवहीला आकार आणि लक्षात ठेवण्याचा कालावधी असतो हे विसरणे — धडा 08

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

खऱ्या account वर तुम्ही NAT gateway ची नोंदवही थेट वाचू शकत नाही — ती तुम्हाला metrics आणि flow logs मधून दिसते. NAT gateway च्या network interface वरचे VPC Flow Logs प्रत्येक translation ची private बाजू आणि public बाजू दाखवतात:

aws ec2 describe-nat-gateways --nat-gateway-ids nat-0abc --query 'NatGateways[].NatGatewayAddresses[].[PublicIp,PrivateIp,NetworkInterfaceId]'
aws ec2 create-flow-logs --resource-type NetworkInterface --resource-ids eni-0abc --traffic-type ALL --log-destination-type cloud-watch-logs --log-group-name nat-flow-logs --deliver-logs-permission-arn arn:aws:iam::111122223333:role/flow-logs
aws cloudwatch get-metric-statistics --namespace AWS/NATGateway --metric-name ActiveConnectionCount --dimensions Name=NatGatewayId,Value=nat-0abc --start-time 2026-09-27T00:00:00Z --end-time 2026-09-27T06:00:00Z --period 300 --statistics Maximum

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: ActiveConnectionCount म्हणजे या क्षणी नोंदवहीचा आकार. कोणतेही business कारण नसताना तो वाढत गेला, तर आतले काहीतरी connections उघडत आहे आणि बंद करत नाही.

⏭️ पुढे

AWS दोन प्रकारची फाटके देते: एक AWS तुमच्यासाठी चालवते, आणि एक तुम्ही EC2 instance पासून बांधता. NAT gateway विरुद्ध NAT instance — scaling, failover, security groups आणि खर्च.

git checkout lesson-03-gateway-vs-instance

📒 Lesson 02 — How the gate remembers (PAT)

📍 You are here: Lesson 02 of 8 · Previous: lesson-01-why-nat · Next: lesson-03-gateway-vs-instance

📦 What's in this branch

Lesson 01, plus the register itself: port address translation (PAT). One public IP serves many private desks, and the gate tells them apart by the port it hands out. pat() in nat/demo.py prints the register row by row.

🧒 Explain like I'm 5

Many pupils go out through the same gate at the same time. All their letters leave with the same school address. So how does the guard know where each answer goes?

The guard gives every trip a ticket number 🎟️ and writes it in the register:

ticket	pupil	went to
1024	desk 25, room 48	the book shop
1025	desk 7, room 64	the book shop
1024	desk 25, room 48	the museum

The answer comes back saying "school address, ticket 1025, from the book shop". The guard reads that row and walks it to desk 7. Two pupils can even use the same private pocket number — the tickets are different, so the answers never mix.

Notice ticket 1024 appears twice. That is fine: one trip went to the book shop, the other to the museum. The guard matches the ticket and who is writing back.

🗺️ Diagram

flowchart LR
    d1["🪑 10.20.48.25:50001"]
    d2["🪑 10.20.64.7:50001"]
    gate["🚪 13.232.10.20<br/>📒 register<br/>1024 ↔ 10.20.48.25:50001 (pypi)<br/>1025 ↔ 10.20.64.7:50001 (pypi)"]
    pypi["🌐 pypi 151.101.0.223:443"]
    d1 -->|"1 out"| gate
    d2 -->|"1 out"| gate
    gate -->|"2 :1024 and :1025"| pypi
    pypi -->|"3 answer to :1025"| gate
    gate -->|"4 row 1025 → 10.20.64.7"| d2

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

❓ What

A connection is identified by five things: source IP, source port, destination IP, destination port, protocol (TCP, UDP or ICMP for a NAT gateway).
PAT (port address translation) — many private addresses share one public address; the gate rewrites the source port too, so each connection gets a unique public IP:port for that destination.
The translation table (the register) — in the model, each row is keyed by (public_ip, public_port, destination) and holds the private (ip, port) and the time it was last used.
Same conversation, same row — a packet from the same desk and port to the same destination reuses its row. That is why a TCP connection keeps one public port for its whole life.
Ports are per destination — public port 1024 can be in use to pypi and to GitHub at the same time. This is why AWS's limit (lesson 08) is per unique destination.
Return traffic — an answer is let in only if its destination IP:port and its source match a row. Everything else is dropped.

🤔 Why

Because there are far fewer public IPv4 addresses than machines. PAT lets a whole VPC share one address (or a few), and the register is also the reason NAT is "outbound only": no row, no entry. When you later debug "connection reset" or "cannot allocate port" errors (lesson 08), you are debugging this register.

🔧 How (in this repo)

In nat/gateway.py, send() first looks for an existing row with the same src and dst and reuses it. If there is none, it takes the lowest free port (from 1024 up) not already used to that destination on that IP, writes the row and returns (public_ip, public_port). pat() in nat/demo.py sends three connections and prints g.table.

🧪 Try it

python3 nat/demo.py pat
python3 - <<'EOF'
import sys; sys.path.insert(0, "nat"); from gateway import NatGateway
GITHUB = ("140.82.112.3", 443, "tcp")
g = NatGateway("nat-a", ["13.232.10.20"])
for desk in ("10.20.48.25", "10.20.64.7", "10.20.80.9"):
    print(desk, "→", g.send((desk, 50001), GITHUB))
print("same desk again →", g.send(("10.20.64.7", 50001), GITHUB), "· rows:", len(g.table))
print("answer on 1026  →", g.reply("13.232.10.20", 1026, GITHUB))
print("answer on 1027  →", g.reply("13.232.10.20", 1027, GITHUB))
EOF

✅ Verify — what you should see

pat prints three translations:

   10.20.48.25:50001  → 151.101.0.223:443  written as 13.232.10.20:1024
   10.20.64.7:50001   → 151.101.0.223:443  written as 13.232.10.20:1025
   10.20.48.25:50002  → 140.82.112.3:443   written as 13.232.10.20:1024

then the register, and answer to 13.232.10.20:1025 from pypi → back to ('10.20.64.7', 50001). Your snippet prints:

10.20.48.25 → ('13.232.10.20', 1024)
10.20.64.7 → ('13.232.10.20', 1025)
10.20.80.9 → ('13.232.10.20', 1026)
same desk again → ('13.232.10.20', 1025) · rows: 3
answer on 1026  → ('10.20.80.9', 50001)
answer on 1027  → None

Three desks used the same private port 50001 and got three different public ports. The repeat did not add a row. Port 1027 was never handed out, so its "answer" was dropped.

🏁 What you just proved

One public IP serves many desks because the gate hands out ports and writes each one down; the register is both the address book for answers and the lock against strangers.

⚠️ Common mistakes

thinking the public port equals the private port — the gate chooses it
expecting the same public port for every connection from one server — each connection gets its own
assuming "one public IP = one connection at a time" — PAT gives tens of thousands per destination
forgetting that the register has a size and a memory time — lesson 08

🏭 In production

On a real account, you cannot read a NAT gateway's register directly — you see it through metrics and flow logs. VPC Flow Logs on the NAT gateway's network interface show the private side and the public side of each translation:

aws ec2 describe-nat-gateways --nat-gateway-ids nat-0abc --query 'NatGateways[].NatGatewayAddresses[].[PublicIp,PrivateIp,NetworkInterfaceId]'
aws ec2 create-flow-logs --resource-type NetworkInterface --resource-ids eni-0abc --traffic-type ALL --log-destination-type cloud-watch-logs --log-group-name nat-flow-logs --deliver-logs-permission-arn arn:aws:iam::111122223333:role/flow-logs
aws cloudwatch get-metric-statistics --namespace AWS/NATGateway --metric-name ActiveConnectionCount --dimensions Name=NatGatewayId,Value=nat-0abc --start-time 2026-09-27T00:00:00Z --end-time 2026-09-27T06:00:00Z --period 300 --statistics Maximum

🏭 Why this matters in production: ActiveConnectionCount is the size of the register right now. When it climbs for no business reason, something inside is opening connections and not closing them.

⏭️ Next

AWS offers two kinds of gate: one it runs for you, and one you build from an EC2 instance. NAT gateway vs NAT instance — scaling, failover, security groups and cost.

git checkout lesson-03-gateway-vs-instance

← Previouswhy nat Next →gateway vs instance

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