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

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

🛵 धडा 02 — Instance types: कामासाठी योग्य वाहन

📍 तुम्ही इथे आहात: 12 पैकी धडा 02 · मागे: lesson-01-why-ec2 · पुढे: lesson-03-amis-launch

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

धडा 01, आणि m7g.large सारखे नाव कसे वाचायचे, रोज भेटणाऱ्या चार families, Graviton स्वस्त का आहे, आणि CPU credits ची burstable इंधन टाकी, जिच्यामुळे t3.micro एक तास वेगवान चालतो आणि त्यानंतर मंद होतो.

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

शाळा लोकांना कामासाठी बाहेर पाठवते. Post office मध्ये पत्र टाकायचे? Scooter 🛵. आठवड्याचा बाजार? Family car 🚗. वेळेशी शर्यत? Racing car 🏎️. ग्रंथालय हलवायचे? ट्रक 🚚. पत्रासाठी ट्रक वापरला तर पैसे वाया जातात; ग्रंथालयासाठी scooter वापरली तर काम कधीच संपत नाही.

EC2 डेस्कचेही तसेच आहे: वेगवेगळ्या कामांसाठी बनवलेल्या families, वेगवेगळ्या sizes मध्ये.

Scooter मध्ये एक गंमत आहे. तिची एक छोटी इंधन टाकी ⛽ आहे, जी तुम्ही हळू चालवता तेव्हा हळूहळू भरते. पूर्ण वेगाने चालवा आणि ती रिकामी होते; एकदा रिकामी झाली की टाकी पुन्हा भरेपर्यंत scooter फक्त चालण्याच्या वेगाने रेंगाळते. ती टाकी म्हणजे CPU credits, आणि म्हणूनच तासभर उडणारा t3.micro अचानक रेंगाळू लागतो.

🗺️ आकृती

flowchart LR
    name["🏷️ m7g.large"]
    fam["m = family<br/>general 🚗"]
    gen["7 = generation"]
    attr["g = Graviton (ARM)"]
    size["large = size<br/>2 vCPU · 8 GiB"]
    name --> fam
    name --> gen
    name --> attr
    name --> size
    t3["🛵 t3.micro: tank of CPU credits<br/>earn 12/h · hold 288"]
    full["hour 1 at 100% → 36 credits left"]
    empty["hour 2 → 0 credits → throttled to 10% baseline"]
    t3 -->|"1 burst"| full -->|"2 tank empty"| empty

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

❓ काय

नाव वाचणे m7g.large: family m, generation 7, attributes g (Graviton / ARM), मग बिंदूनंतर size. तुम्हाला दिसतील अशी इतर attribute अक्षरे: i Intel, a AMD, d local NVMe instance store (धडा 04), n जास्तीचा network bandwidth.
Families: t burstable 🛵 (छोटी, अधूनमधून वाढणारी कामे), m general purpose 🚗 (संतुलित — पहिला अंदाज हाच), c compute optimised 🏎️ (प्रत्येक GiB मागे जास्त CPU), r memory optimised 🚚 (प्रत्येक CPU मागे जास्त GiB). आणखीही आहेत: i storage, g/p GPUs, x खूप मोठी memory.
Sizes प्रत्येक पायरीवर साधारण दुप्पट होतात: large (2 vCPU) → xlarge (4) → 2xlarge (8) … आणि किंमतही सोबत दुप्पट होते. एक vCPU म्हणजे एक hardware thread.
Graviton (g) — AWS चे स्वतःचे ARM processors. या lab च्या अंदाजे किमतींनुसार m7g.large हा m7i.large पेक्षा दर तासाला सुमारे 19% स्वस्त आहे, आणि बऱ्याचदा प्रति dollar जास्त वेगवान — पण तुमचे software आणि AMI arm64 साठी build केलेले असले पाहिजेत.
Burstable (T family) — कमी baseline (t3.micro साठी प्रति vCPU 10%) आणि CPU credits: t3.micro तासाला 12 credits कमावतो, जास्तीत जास्त 288 साठवतो, आणि 1 credit = 1 vCPU 100% वर 1 मिनिट. Standard mode मध्ये balance रिकामा झाला की तुम्हाला baseline पर्यंत throttle केले जाते. Unlimited mode मध्ये (T3 आणि T4g साठी default) throttle होत नाही — त्याऐवजी जास्तीच्या वापराचे वेगळे पैसे भरता. टाकी तुम्हाला दिसावी म्हणून lab standard mode चे model वापरते.
प्रत्येक type प्रत्येक Region किंवा AZ मध्ये असतोच असे नाही — design करण्याआधी तपासा.

🤔 का

कारण instance type म्हणजेच बिलाचा आणि performance चा मोठा भाग, आणि तो launch screen वर दहा सेकंदांत निवडला जातो. चुकीची family दर तासाला पैसे वाया घालवते (memory ची भूक असलेल्या cache साठी c डेस्क) किंवा bug सारख्या दिसणाऱ्या पद्धतीने अपयशी ठरते (दुपारनंतर "उगाचच" मंद होणारा t3).

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

ec2/demo.py मधले types() ec2/costs.py मधली lab ची किंमत-यादी प्रत्येक family च्या वाहनासह छापते, मग ec2/fleet.py मधले fleet.credits(3) चालवते: 144 credits पासून सुरू होणारा, तीन तास 100% वर चालणारा t3.micro, मिनिटा-मिनिटाने.

🧪 करून पाहा

python3 ec2/demo.py types
python3 - <<'EOF'
import sys; sys.path.insert(0, "ec2"); import costs, fleet
# price per GiB of memory: which family is the cheap way to buy RAM?
for t, (v, m, p) in costs.PRICE_PER_HOUR.items():
    print(f"{t:<11} ${p / m:.4f} per GiB-hour")
# a gentle load: 10% on both vCPUs is exactly the baseline → the tank never empties
print("10% busy:", fleet.credits(3, busy_pct=10))
# 30% busy spends 0.6 credits a minute but earns only 0.2 → it drains 24 an hour
for h, bal, got in fleet.credits(8, busy_pct=30):
    print(f"30% busy · hour {h}: {bal:>5} credits · CPU {got}%")
EOF

खऱ्या account वर (AWS credentials लागतात; फक्त वाचणे, मोफत):

aws ec2 describe-instance-types --instance-types t3.micro m7g.large r7g.large \
    --query 'InstanceTypes[].[InstanceType,VCpuInfo.DefaultVCpus,MemoryInfo.SizeInMiB,ProcessorInfo.SupportedArchitectures[0]]' \
    --output table
aws ec2 describe-instance-type-offerings --location-type availability-zone \
    --filters Name=instance-type,Values=m7g.large --region us-east-1 --output table

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

types आठ types ची यादी दाखवते, t3.micro 2 vCPU 1 GiB burstable 🛵 ~$0.0104/h पासून r7g.large 2 vCPU 16 GiB memory 🚚 ~$0.1071/h पर्यंत, मग टाकी: hour 1: balance 36.0 credits · you get 100% CPU आणि, तास 2 पासून, balance 0.0 credits · you get 10% CPU ← tank empty: throttled to the 10% baseline. तुमचा snippet दाखवतो की RAM विकत घेण्याचा स्वस्त मार्ग memory families आहेत (r7g.large $0.0067 per GiB-hour वर, आणि सर्वात महाग c7i.xlarge $0.0223 वर), 10% चा run दर तासाला 144.0 credits वर स्थिर राहतो, आणि 30% चा run तासाला 24 ने कमी होत जातो (120.0, 96.0, … 0.0), जोपर्यंत तास 7 ला CPU 10% वर येत नाही.

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

तुम्ही कोणतेही instance नाव वाचू शकता, पहिला अंदाज कोणत्या family चा करायचा ते तुम्हाला माहीत आहे, आणि तुम्ही burstable डेस्कचे इंधन संपताना पाहिले — पूर्ण load वर दोन तासांच्या आत, 30% load वर सहा तासांत.

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

स्थिर, सतत व्यस्त workload t instance वर चालवणे — ती scooter आहे, car नाही
CPUCreditBalance कडे दुर्लक्ष करून मंद दुपारीसाठी code ला दोष देणे (धडा 11)
software चा arm64 build (आणि arm64 AMI) नसताना Graviton निवडणे
"सुरक्षित राहावे" म्हणून सर्वात मोठा size निवडणे — आधी मोजा, मग size कमी करा
जुनी generation स्वस्त असेल असे गृहीत धरणे; नव्या generations बऱ्याचदा स्वस्त आणि वेगवान असतात

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: प्रत्येक cost review ची पहिली ओळ right-sizing असते. AWS Compute Optimizer सारखी tools तुमचे खरे CPU आणि memory graphs वाचून लहान किंवा Graviton type सुचवतात — ती बचत दर तासाला, कायमची, होत राहते.

⏭️ पुढे

कोणी बसण्याआधी प्रत्येक डेस्कवर काहीतरी हवे. डेस्कचा साचा आणि recipe card — AMIs आणि launch templates.

git checkout lesson-03-amis-launch

🛵 Lesson 02 — Instance types: the right vehicle for the errand

📍 You are here: Lesson 02 of 12 · Previous: lesson-01-why-ec2 · Next: lesson-03-amis-launch

📦 What's in this branch

Lesson 01, plus how to read a name like m7g.large, the four families you will meet every day, why Graviton is cheaper, and the burstable fuel tank of CPU credits that makes a t3.micro fast for an hour and slow after it.

🧒 Explain like I'm 5

The school sends people on errands. A letter to the post office? A scooter 🛵. The weekly shop? A family car 🚗. A race against the clock? A racing car 🏎️. Moving the library? A lorry 🚚. Using the lorry for the letter wastes money; using the scooter for the library never finishes.

EC2 desks are the same: families built for different jobs, in different sizes.

The scooter has a twist. It has a small fuel tank ⛽ that refills slowly while you ride gently. Ride flat out and you empty it; once it is empty, the scooter only crawls at walking pace until the tank refills. That tank is CPU credits, and it is why a t3.micro that flew for an hour suddenly crawls.

🗺️ Diagram

flowchart LR
    name["🏷️ m7g.large"]
    fam["m = family<br/>general 🚗"]
    gen["7 = generation"]
    attr["g = Graviton (ARM)"]
    size["large = size<br/>2 vCPU · 8 GiB"]
    name --> fam
    name --> gen
    name --> attr
    name --> size
    t3["🛵 t3.micro: tank of CPU credits<br/>earn 12/h · hold 288"]
    full["hour 1 at 100% → 36 credits left"]
    empty["hour 2 → 0 credits → throttled to 10% baseline"]
    t3 -->|"1 burst"| full -->|"2 tank empty"| empty

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

❓ What

Reading the name m7g.large: family m, generation 7, attributes g (Graviton / ARM), then the size after the dot. Other attribute letters you will see: i Intel, a AMD, d local NVMe instance store (lesson 04), n extra network bandwidth.
Families: t burstable 🛵 (small, spiky jobs), m general purpose 🚗 (balanced — the default guess), c compute optimised 🏎️ (more CPU per GiB), r memory optimised 🚚 (more GiB per CPU). There are more: i storage, g/p GPUs, x very large memory.
Sizes roughly double each step: large (2 vCPU) → xlarge (4) → 2xlarge (8) … and the price doubles with it. A vCPU is one hardware thread.
Graviton (g) — AWS's own ARM processors. In this lab's approximate prices an m7g.large is about 19% cheaper per hour than an m7i.large, and often faster per dollar — but your software and AMI must be built for arm64.
Burstable (T family) — a low baseline (10% per vCPU for a t3.micro) plus CPU credits: a t3.micro earns 12 credits an hour, holds at most 288, and 1 credit = 1 vCPU at 100% for 1 minute. In standard mode an empty balance throttles you to the baseline. In unlimited mode (the default for T3 and T4g) you are not throttled — you pay extra for the surplus instead. The lab models standard mode so you can see the tank.
Not every type exists in every Region or AZ — check before you design.

🤔 Why

Because the instance type is most of the bill and most of the performance, and it is chosen in ten seconds on a launch screen. The wrong family wastes money every hour (a c desk for a memory-hungry cache) or fails in a way that looks like a bug (a t3 that "randomly" slows after lunch).

🔧 How (in this repo)

types() in ec2/demo.py prints the lab's price list from ec2/costs.py with each family's vehicle, then runs fleet.credits(3) from ec2/fleet.py: a t3.micro at 100% for three hours, starting with 144 credits, minute by minute.

🧪 Try it

python3 ec2/demo.py types
python3 - <<'EOF'
import sys; sys.path.insert(0, "ec2"); import costs, fleet
# price per GiB of memory: which family is the cheap way to buy RAM?
for t, (v, m, p) in costs.PRICE_PER_HOUR.items():
    print(f"{t:<11} ${p / m:.4f} per GiB-hour")
# a gentle load: 10% on both vCPUs is exactly the baseline → the tank never empties
print("10% busy:", fleet.credits(3, busy_pct=10))
# 30% busy spends 0.6 credits a minute but earns only 0.2 → it drains 24 an hour
for h, bal, got in fleet.credits(8, busy_pct=30):
    print(f"30% busy · hour {h}: {bal:>5} credits · CPU {got}%")
EOF

On a real account (needs AWS credentials; read-only, free):

aws ec2 describe-instance-types --instance-types t3.micro m7g.large r7g.large \
    --query 'InstanceTypes[].[InstanceType,VCpuInfo.DefaultVCpus,MemoryInfo.SizeInMiB,ProcessorInfo.SupportedArchitectures[0]]' \
    --output table
aws ec2 describe-instance-type-offerings --location-type availability-zone \
    --filters Name=instance-type,Values=m7g.large --region us-east-1 --output table

✅ Verify — what you should see

types lists eight types from t3.micro 2 vCPU 1 GiB burstable 🛵 ~$0.0104/h to r7g.large 2 vCPU 16 GiB memory 🚚 ~$0.1071/h, then the tank: hour 1: balance 36.0 credits · you get 100% CPU and, from hour 2, balance 0.0 credits · you get 10% CPU ← tank empty: throttled to the 10% baseline. Your snippet shows the memory families are the cheap way to buy RAM (r7g.large at $0.0067 per GiB-hour, c7i.xlarge the dearest at $0.0223), the 10% run holding steady at 144.0 credits every hour, and the 30% run draining 24 an hour (120.0, 96.0, … 0.0) until hour 7 drops to CPU 10%.

🏁 What you just proved

You can read any instance name, you know which family to guess first, and you watched a burstable desk run out of fuel — at full load in under two hours, at 30% load in six.

⚠️ Common mistakes

running a steady, busy workload on a t instance — it is a scooter, not a car
ignoring CPUCreditBalance and blaming the code for a slow afternoon (lesson 11)
choosing Graviton without an arm64 build of the software (and an arm64 AMI)
picking the biggest size "to be safe" — measure, then size down
assuming an old generation is cheaper; newer generations are often cheaper and faster

🏭 Why this matters in production: right-sizing is the first line on every cost review. Tools like AWS Compute Optimizer read your real CPU and memory graphs and suggest a smaller or Graviton type — the saving repeats every hour, forever.

⏭️ Next

Every desk needs something on it before anyone sits down. The desk template and the recipe card — AMIs and launch templates.

git checkout lesson-03-amis-launch

← Previouswhy ec2 Next →amis launch

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