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

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

🖼️ धडा 03 — AMIs आणि launch templates: डेस्कचा साचा आणि recipe card

📍 तुम्ही इथे आहात: 12 पैकी धडा 03 · मागे: lesson-02-instance-types · पुढे: lesson-04-storage

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

धडे 01–02, आणि instance कशापासून बनतो ते: AMI (डेस्कचा साचा), launch template (AMI, type, disk, badge आणि पाहुण्यांची यादी लिहिलेले recipe card), आणि user data — पहिल्या boot ची script, ec2/templates/user-data.sh. Recipe card स्वतः ec2/templates/web.json आहे.

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

अभ्यासिकेत नवा डेस्क आला की तो शून्यापासून तयार करायला कोणालाच आवडत नाही: दिवा बसवा, stationery ठेवा, भिंतीवर वेळापत्रक चिकटवा. म्हणून कंपनी एक डेस्कचा साचा 🖼️ ठेवते — अगदी फोटोसारखा परिपूर्ण, आधीच तयार केलेला डेस्क. प्रत्येक नवा डेस्क त्याची नक्कल करून बनतो. तो साचा म्हणजे AMI (Amazon Machine Image).

मग भिंतीवर लावलेले एक recipe card 📇 असते: "एक t4g.small डेस्क, ami-0abc… साच्यावरून नक्कल केलेला, 16 GB ड्रॉवरसह, हा badge, ही पाहुण्यांची यादी — आणि तो नवा असताना या तीन पायऱ्या एकदा चालवा". ते card म्हणजे launch template. "या पायऱ्या एकदा चालवा" हा भाग म्हणजे user data.

Card कशासाठी? कारण दहावा डेस्क पहिल्यासारखाच हुबेहूब असला पाहिजे. एखादा डेस्क बिघडला तर तुम्ही तो एकेक screw करून दुरुस्त करत नाही — तो फेकून देऊन card वरून नवा बनवता.

🗺️ आकृती

flowchart LR
    ami["🖼️ AMI ami-0abc1234example<br/>OS + software, arm64"]
    lt["📇 launch template web.json<br/>t4g.small · 16 GB gp3 · badge school-web · sg-0web"]
    ud["📜 user-data.sh<br/>dnf install nginx · write index.html · enable nginx"]
    d1["🖥️ desk 1"]
    d2["🖥️ desk 2"]
    d3["🖥️ desk 3"]
    ami -->|"1 copied from"| lt
    ud -->|"2 runs once, as root, first boot"| lt
    lt -->|"3 launch"| d1
    lt --> d2
    lt --> d3
    same["✅ every desk identical — broken? replace, never repair manually"]
    d3 -.-> same

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

❓ काय

AMI — boot करण्यासाठीची image: root volume चा snapshot (धडा 04) आणि metadata (architecture x86_64 किंवा arm64, boot mode, block device mapping, ती कोण launch करू शकतो). AMIs regional असतात — तेच Amazon Linux प्रत्येक Region मध्ये वेगळ्या AMI ID ने असते — आणि तुम्ही स्वतःच्या AMIs इतर Regions मध्ये copy करू शकता.
AMIs कुठून येतात — AWS (Amazon Linux 2023, Windows), vendors (Ubuntu, Red Hat, Marketplace), किंवा तुम्ही (एक "golden" AMI, धडा 12). कालबाह्य होणारा ID hard-code करण्याऐवजी नवीनतम Amazon Linux सार्वजनिक SSM parameters मधून शोधा.
Launch template — versions असलेली recipe: ImageId, InstanceType, IamInstanceProfile (badge, धडा 07), SecurityGroupIds (पाहुण्यांची यादी, धडा 05), BlockDeviceMappings (disks, धडा 04), MetadataOptions, tags आणि UserData. प्रत्येक बदलाने नवी version बनते; तुम्ही गोष्टी $Latest किंवा $Default किंवा एखाद्या क्रमांकाकडे निर्देशित करता. Auto Scaling (धडा 09) एका template वरून launch करते.
User data — एक script (किंवा cloud-init config) जी default नुसार पहिल्या boot ला, root म्हणून, एकदाच चालते. Launch template मध्ये ती base64-encoded असावी लागते; मूळ script ची मर्यादा 16 KB आहे. Instance चे attributes वाचू शकणारा कोणीही ती वाचू शकतो — म्हणून user data मध्ये कोणतीही secrets नकोत.
Bake विरुद्ध bootstrap — गोष्टी AMI मध्ये ठेवा (जलद boot, काळात गोठलेले) किंवा user data मध्ये install करा (नेहमी ताजे, boot मंद). बहुतेक teams दोन्ही करतात: bake केलेला पाया, आणि छोटा bootstrap.

🤔 का

कारण हाताने तयार केलेला server पुन्हा कोणालाच बनवता येत नाही. Recipe card मुळे दहावा डेस्क पहिल्यासारखाच बनतो, Auto Scaling तुमच्याशिवाय रात्री 3 वाजता डेस्क बनवू शकते, आणि "बिघडलेला डेस्क दुरुस्त करा" चे रूपांतर "तो बदला" मध्ये होते — धडा 09 आणि धडा 12 मागची हीच सवय.

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

ec2/demo.py मधले launch() ec2/templates/web.json उघडते — जी AWS CLI ला दिल्या जाणाऱ्या --launch-template-data सारखीच रचलेली आहे — मुख्य fields छापते, मग पहिल्या boot ची script ec2/templates/user-data.sh छापते. ImageId हा placeholder आहे (ami-0abc1234example) आणि UserData मध्ये (base64 of user-data.sh) लिहिलेले आहे: खऱ्या account वर तुम्ही दोन्ही बदलता.

🧪 करून पाहा

python3 ec2/demo.py launch
python3 - <<'EOF'
import base64, json
t = json.load(open("ec2/templates/web.json"))
print("disk:", t["BlockDeviceMappings"][0]["Ebs"])
print("metadata:", t["MetadataOptions"])
print("tags:", t["TagSpecifications"][0]["Tags"])
# a launch template wants UserData base64-encoded — this is what replaces the placeholder
ud = base64.b64encode(open("ec2/templates/user-data.sh", "rb").read()).decode()
print("UserData:", ud[:40] + "…", f"({len(ud)} characters)")
EOF

खऱ्या account वर (AWS credentials लागतात; run-instances ने billing सुरू होते — नंतर terminate करा). आधी web.json च्या एका copy मध्ये खरा arm64 AMI ID, खरा security group ID आणि base64 user data टाका, आणि school-web instance profile बनवा (धडा 07) — किंवा सध्या ती ओळ काढून टाका:

aws ssm get-parameter \
    --name /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64 \
    --query Parameter.Value --output text
aws ec2 create-launch-template --launch-template-name school-web \
    --launch-template-data file://my-web.json
aws ec2 run-instances --launch-template 'LaunchTemplateName=school-web,Version=$Latest' --count 1
aws ec2 terminate-instances --instance-ids i-0123456789abcdef0

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

launch छापते ImageId "ami-0abc1234example", InstanceType "t4g.small", IamInstanceProfile {"Name": "school-web"}, SecurityGroupIds ["sg-0web"], मग UserData (runs once, as root, on first boot): खाली script च्या तीन ओळी — dnf install -y nginx, index.html मध्ये जाणारा echo, आणि systemctl enable --now nginx. तुमचा snippet disk छापतो ('VolumeSize': 16, 'VolumeType': 'gp3', 'Encrypted': True, 'DeleteOnTermination': True), metadata options ('HttpTokens': 'required', 'HttpPutResponseHopLimit': 1 — धडा 07 त्यांचे स्पष्टीकरण देतो), tag 'Key': 'team', 'Value': 'maths', आणि UserData: IyEvYmluL2Jhc2gKIyBSdW5zIE9OQ0UsIGFzIHJv… (328 characters).

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

एक recipe card आणि एक साचा डेस्कचे पूर्ण वर्णन करतात — तुम्ही त्याची प्रत्येक ओळ वाचली, पहिल्या boot ला एकदा चालणाऱ्या script सह, आणि खऱ्या launch template ला लागणारा नेमका base64 तयार केला.

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

scripts मध्ये AMI ID hard-code करणे — तो प्रत्येक Region मध्ये वेगळा असतो आणि कालबाह्य होतो; SSM parameter वाचा
arm64 instance type (t4g, m7g) सोबत x86_64 AMI, किंवा उलट — launch अपयशी ठरते
user data मध्ये passwords किंवा keys ठेवणे — ती वाचता येणारी metadata आहे, तिजोरी नाही
user data प्रत्येक reboot ला चालेल अशी अपेक्षा करणे — default नुसार ती फक्त पहिल्या boot ला चालते
launch नंतर डेस्क हाताने दुरुस्त करणे, ज्यामुळे recipe card आता खरे सांगत नाही

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: Auto Scaling, instance refresh आणि disaster recovery हे सगळे launch template हेच डेस्कबद्दलचे पूर्ण सत्य आहे असे गृहीत धरतात. Teams ते code मध्ये ठेवतात (CloudFormation, Terraform, CDK), code सारखेच review करतात, आणि "फक्त एक गोष्ट दुरुस्त करायला" कधीच login करत नाहीत.

⏭️ पुढे

डेस्कला एक ड्रॉवर, एक खरडवही आणि hall च्या टोकाला एक photocopier आहे — आणि ते अगदी वेगवेगळ्या गोष्टींनंतर टिकतात. Storage: EBS आणि snapshots.

git checkout lesson-04-storage

🖼️ Lesson 03 — AMIs & launch templates: the desk template and the recipe card

📍 You are here: Lesson 03 of 12 · Previous: lesson-02-instance-types · Next: lesson-04-storage

📦 What's in this branch

Lessons 01–02, plus what an instance is built from: the AMI (the desk template), the launch template (the recipe card that names the AMI, type, disk, badge and guest list), and user data — the first-boot script in ec2/templates/user-data.sh. The recipe card itself is ec2/templates/web.json.

🧒 Explain like I'm 5

When the study hall gets a new desk, nobody wants to set it up from nothing: screw on the lamp, put the stationery in, stick the timetable on the wall. So the company keeps a desk template 🖼️ — a photo-perfect desk, already set up. Every new desk is copied from it. That template is an AMI (Amazon Machine Image).

Then there is the recipe card 📇 pinned to the wall: "a t4g.small desk, copied from template ami-0abc…, with a 16 GB drawer, this badge, this guest list — and when it is new, run these three steps once". That card is a launch template. The "run these steps once" part is user data.

Why a card? Because the tenth desk must be identical to the first. If a desk breaks, you do not repair it one screw at a time — you throw it out and build a new one from the card.

🗺️ Diagram

flowchart LR
    ami["🖼️ AMI ami-0abc1234example<br/>OS + software, arm64"]
    lt["📇 launch template web.json<br/>t4g.small · 16 GB gp3 · badge school-web · sg-0web"]
    ud["📜 user-data.sh<br/>dnf install nginx · write index.html · enable nginx"]
    d1["🖥️ desk 1"]
    d2["🖥️ desk 2"]
    d3["🖥️ desk 3"]
    ami -->|"1 copied from"| lt
    ud -->|"2 runs once, as root, first boot"| lt
    lt -->|"3 launch"| d1
    lt --> d2
    lt --> d3
    same["✅ every desk identical — broken? replace, never repair manually"]
    d3 -.-> same

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

❓ What

AMI — an image to boot from: a snapshot of the root volume (lesson 04) plus metadata (architecture x86_64 or arm64, boot mode, block device mapping, who may launch it). AMIs are regional — the same Amazon Linux has a different AMI ID in every Region — and you can copy your own to other Regions.
Where AMIs come from — AWS (Amazon Linux 2023, Windows), vendors (Ubuntu, Red Hat, Marketplace), or you (a "golden" AMI, lesson 12). Find the latest Amazon Linux through the public SSM parameters instead of hard-coding an ID that goes stale.
Launch template — a versioned recipe: ImageId, InstanceType, IamInstanceProfile (the badge, lesson 07), SecurityGroupIds (the guest list, lesson 05), BlockDeviceMappings (the disks, lesson 04), MetadataOptions, tags and UserData. Every change makes a new version; you point things at $Latest or $Default or a number. Auto Scaling (lesson 09) launches from one.
User data — a script (or cloud-init config) that runs once, as root, on the first boot, by default. In a launch template it must be base64-encoded; the raw script is limited to 16 KB. Anyone who can read the instance's attributes can read it — so no secrets in user data.
Bake vs bootstrap — put things in the AMI (fast boot, frozen in time) or install them in user data (always fresh, slower boot). Most teams do both: a baked base, a short bootstrap.

🤔 Why

Because a server set up manually is a server nobody can build again. The recipe card makes the tenth desk the same as the first, lets Auto Scaling build desks at 3 a.m. without you, and turns "fix the broken desk" into "replace it" — the habit behind lesson 09 and lesson 12.

🔧 How (in this repo)

launch() in ec2/demo.py opens ec2/templates/web.json — shaped exactly like the --launch-template-data you give the AWS CLI — prints the key fields, then prints the first-boot script ec2/templates/user-data.sh. The ImageId is a placeholder (ami-0abc1234example) and UserData says (base64 of user-data.sh): on a real account you replace both.

🧪 Try it

python3 ec2/demo.py launch
python3 - <<'EOF'
import base64, json
t = json.load(open("ec2/templates/web.json"))
print("disk:", t["BlockDeviceMappings"][0]["Ebs"])
print("metadata:", t["MetadataOptions"])
print("tags:", t["TagSpecifications"][0]["Tags"])
# a launch template wants UserData base64-encoded — this is what replaces the placeholder
ud = base64.b64encode(open("ec2/templates/user-data.sh", "rb").read()).decode()
print("UserData:", ud[:40] + "…", f"({len(ud)} characters)")
EOF

On a real account (needs AWS credentials; run-instances starts billing — terminate it afterwards). First put a real arm64 AMI ID, a real security group ID and the base64 user data into a copy of web.json, and create the school-web instance profile (lesson 07) — or delete that line for now:

aws ssm get-parameter \
    --name /aws/service/ami-amazon-linux-latest/al2023-ami-kernel-default-arm64 \
    --query Parameter.Value --output text
aws ec2 create-launch-template --launch-template-name school-web \
    --launch-template-data file://my-web.json
aws ec2 run-instances --launch-template 'LaunchTemplateName=school-web,Version=$Latest' --count 1
aws ec2 terminate-instances --instance-ids i-0123456789abcdef0

✅ Verify — what you should see

launch prints ImageId "ami-0abc1234example", InstanceType "t4g.small", IamInstanceProfile {"Name": "school-web"}, SecurityGroupIds ["sg-0web"], then the three script lines under UserData (runs once, as root, on first boot): — dnf install -y nginx, the echo into index.html, and systemctl enable --now nginx. Your snippet prints the disk ('VolumeSize': 16, 'VolumeType': 'gp3', 'Encrypted': True, 'DeleteOnTermination': True), the metadata options ('HttpTokens': 'required', 'HttpPutResponseHopLimit': 1 — lesson 07 explains them), the tag 'Key': 'team', 'Value': 'maths', and UserData: IyEvYmluL2Jhc2gKIyBSdW5zIE9OQ0UsIGFzIHJv… (328 characters).

🏁 What you just proved

A desk is fully described by a recipe card and a template — you read every line of it, including the script that runs once on first boot, and produced the exact base64 a real launch template needs.

⚠️ Common mistakes

hard-coding an AMI ID in scripts — it differs per Region and goes stale; read the SSM parameter
an arm64 instance type (t4g, m7g) with an x86_64 AMI, or the other way round — the launch fails
putting passwords or keys in user data — it is readable metadata, not a vault
expecting user data to run on every reboot — by default it runs on the first boot only
fixing a desk manually after launch, so the recipe card no longer tells the truth

🏭 Why this matters in production: Auto Scaling, instance refresh and disaster recovery all assume the launch template is the complete truth about a desk. Teams keep it in code (CloudFormation, Terraform, CDK), review it like code, and never log in to "just fix one thing".

⏭️ Next

The desk has a drawer, a scratch pad and a photocopier down the hall — and they survive very different things. Storage: EBS and snapshots.

git checkout lesson-04-storage

← Previousinstance types Next →storage

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