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

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

⚡ धडा 19 — Lambda: फक्त बोलावल्यावरच अस्तित्वात असणारा मदतनीस (serverless functions)

📍 तुम्ही इथे आहात: 20 पैकी धडा 19 · मागील: lesson-18-cloudwatch · पुढील: lesson-20-the-bill

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

धडे 01–19. Code चालवण्याचा दुसरा मार्ग — बाकच नाही. खरी file:

lambda/hello.py — संपूर्ण "server"

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

बाक भाड्याने घेणे (EC2) म्हणजे बाक रिकामा बसलेला असतानाही पैसे भरणे. पण काही कामे म्हणजे छोटी कामे असतात: फोटो upload झाला की त्याचा आकार बदला, मध्यरात्री एक अहवाल चालवा. अशा कामांसाठी शाळेकडे एक जादुई बोलावल्यावर येणारा मदतनीस ⚡ आहे: Lambda.

एक event घडतो 🔔 — locker room मध्ये एक डबा येतो (S3 upload), सकाळची घंटा वाजते (schedule), कोणीतरी URL ला call करते.
मदतनीस अचानक अस्तित्वात येतो 💨, नेमके ते एकच काम करतो (जास्तीत जास्त 15 मिनिटे), आणि नाहीसा होतो.
तुम्ही प्रत्येक कामासाठी, प्रति 100 ms पैसे भरता — रिकामा मदतनीस शून्य खर्चाचा. एकदम हजार डबे आले? हजार मदतनीस हजर होतात. Scaling हे तुम्ही configure करायचे feature नाही; "प्रत्येक कामाला एक मदतनीस" याचा अर्थच तो आहे.

दोन प्रामाणिक तळटीपा:

Cold starts 🥶: बराच वेळ न बोलावलेला मदतनीस काम सुरू करण्याआधी ~100 ms–2 s "बूट घालण्यात" घालवतो. सहसा चालते; latency-critical APIs साठी महत्त्वाचे ठरते.
मदतनीस IAM टोपी घालतो 🎩 (धडा 04, अर्थातच): त्याचा execution role म्हणजे ते काम नेमके कशाला हात लावू शकते — हा S3 bucket, ती log डायरी, बाकी काही नाही.

🗺️ आकृती

flowchart LR
    ev["🔔 events<br/>📦 S3 upload · ⏰ schedule · 🌐 URL"]
    fn["⚡ helper appears 💨<br/>runs hello.py<br/>≤ 15 min, per-100ms billing"]
    hat["🎩 execution role<br/>may touch: this bucket, logs"]
    out["✅ errand done<br/>result → S3 / response"]
    gone["👻 …vanishes<br/>idle cost: $0"]
    ev -->|"1"| fn
    hat -->|"2 worn during"| fn
    fn -->|"3"| out
    fn -->|"4"| gone

❓ काय

Function = तुमचा code + runtime (Python/Node/…) + memory size (CPU memory सोबतच वाढतो — एकमेव बटण) + timeout + execution role.
Triggers सगळीकडे: S3, SQS queues, EventBridge schedules (cluster शिवाय CronJobs — k8s धडा 18 ची घंटा, serverless), ALB target groups (धडा 15 — reception मदतनिसांकडेही पाठवू शकते!), झटपट HTTP साठी function URLs.
केव्हा नाही: सतत जड traffic (स्थिर भारावर प्रत्येक request ला मदतनीसापेक्षा भाड्याचा बाक स्वस्त), 15 मिनिटांपेक्षा मोठी कामे, खास hardware, किंवा जड दीर्घकाळ चालणारे connections. Scooter/truck चा धडा (08) paradigms लाही लागू होतो.
Logs: प्रत्येक print आपोआप CloudWatch डायऱ्यांत (धडा 18) जाते — नाहीशा झालेल्या मदतनीसामध्ये डोकावण्याची तुमची एकमेव खिडकी.

🤔 का

"Code कुठे चालतो" याचे हे तिसरे उत्तर आहे: बाक भाड्याने घ्या (EC2), बाकांची शाळा चालवा (k8s), किंवा कामांचे वर्णन करा (Lambda). खऱ्या systems चे संपूर्ण जोडणी-थर — thumbnails, webhooks, रात्रीची साफसफाई, धडा 12 मधल्या ops scripts — छोटी कामे म्हणून सर्वात स्वस्त आणि सोपे असतात. तिन्ही paradigms (आणि त्यांची bills) माहीत असणे म्हणजेच "architect" असणे.

🔧 कसे

zip fn.zip hello.py
aws lambda create-function --function-name hello --runtime python3.12 \
  --handler hello.handler --zip-file fileb://fn.zip --role $HELPER_ROLE_ARN
aws lambda invoke --function-name hello --payload '{"name":"class 3A"}' out.json
cat out.json     # {"greeting": "hello, class 3A"}

🧪 करून पाहा (~10 मिनिटे, मोफत — महिन्याला दहा लाख कामे $0)

वरच्या चार commands चालवा (role ची trust policy धडा 04 चीच, शब्दशः — टोपी कोण घालू शकतो: lambda.amazonaws.com). ते पाच वेळा पटापट invoke करा; CloudWatch डायरीतल्या REPORT ओळी वाचा — milliseconds मध्ये, एक cold start आणि चार warm ओळखा.

aws lambda delete-function --function-name hello   # tidy, as always

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

aws lambda invoke {"greeting": "hello, class 3A"} लिहितो; CloudWatch log group एक cold Init Duration आणि चार warm invocations दाखवतो.

🧹 साफसफाई — चालू ठेवू नका

aws lambda delete-function --function-name hello — दहा लाख invocations मोफत आहेत, तरीही नीटनेटके ठेवा

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

15 मिनिटांची मर्यादा असलेल्या मदतनीसाला 15 मिनिटांचे काम
Execution role ला * देणे — टोप्याही least-privilege असतात
Invocations दरम्यान state ची अपेक्षा — मदतनीस विसरतात

⏭️ पुढे

तुम्ही आता बाक, lockers, receptions, कार्यालये आणि मदतनीस भाड्याने घेता. एक कौशल्य उरले, आणि तेच हा छंद परवडणारा ठेवते: मीटर वाचणे. धडा 20 — bill.

⚡ Lesson 19 — Lambda: the helper who exists only while called (serverless functions)

📍 You are here: Lesson 19 of 20 · Previous: lesson-18-cloudwatch · Next: lesson-20-the-bill

📦 What's in this branch

Lessons 01–19. The other way to run code — no desk at all. Real file:

lambda/hello.py — the entire "server"

🧒 Explain like I'm 5

Renting a desk (EC2) means paying for the desk while it sits empty. But some jobs are errands: resize a photo when one is uploaded, run a report at midnight. For errands, the school has a magical on-call helper ⚡: Lambda.

An event happens 🔔 — a box lands in the locker room (S3 upload), the morning bell rings (schedule), someone calls a URL.
The helper pops into existence 💨, does exactly that one errand (15 minutes maximum), and vanishes.
You pay per errand, per 100 ms — an idle helper costs zero. A thousand boxes land at once? A thousand helpers appear. Scaling isn't a feature you configure; it's just what "one helper per errand" means.

Two honest footnotes:

Cold starts 🥶: a helper who hasn't been called in a while spends ~100 ms–2 s "putting their shoes on" before working. Usually fine; matters for latency-critical APIs.
The helper carries an IAM hat 🎩 (lesson 04, of course): its execution role is exactly what the errand may touch — this S3 bucket, that log diary, nothing else.

🗺️ Diagram

flowchart LR
    ev["🔔 events<br/>📦 S3 upload · ⏰ schedule · 🌐 URL"]
    fn["⚡ helper appears 💨<br/>runs hello.py<br/>≤ 15 min, per-100ms billing"]
    hat["🎩 execution role<br/>may touch: this bucket, logs"]
    out["✅ errand done<br/>result → S3 / response"]
    gone["👻 …vanishes<br/>idle cost: $0"]
    ev -->|"1"| fn
    hat -->|"2 worn during"| fn
    fn -->|"3"| out
    fn -->|"4"| gone

❓ What

Function = your code + runtime (Python/Node/…) + memory size (CPU scales WITH memory — the one dial) + timeout + execution role.
Triggers everywhere: S3, SQS queues, EventBridge schedules (CronJobs without a cluster — k8s lesson 18's bell, serverless), ALB target groups (lesson 15 — reception can route to helpers!), function URLs for quick HTTP.
When NOT: steady heavy traffic (a rented desk is cheaper than helpers-per-request at constant load), jobs > 15 min, special hardware, or heavy long-lived connections. The scooter/truck lesson (08) applies to paradigms too.
Logs: every print lands in CloudWatch diaries (lesson 18) automatically — your only window into a vanished helper.

🤔 Why

This is the third answer to "where does code run": rent desks (EC2), run a school of desks (k8s), or describe errands (Lambda). Whole glue-layers of real systems — thumbnails, webhooks, nightly cleanups, the ops scripts from lesson 12 — are cheapest and simplest as errands. Knowing all three paradigms (and their bills) is what "architect" means.

🔧 How

zip fn.zip hello.py
aws lambda create-function --function-name hello --runtime python3.12 \
  --handler hello.handler --zip-file fileb://fn.zip --role $HELPER_ROLE_ARN
aws lambda invoke --function-name hello --payload '{"name":"class 3A"}' out.json
cat out.json     # {"greeting": "hello, class 3A"}

🧪 Try it (~10 min, free — a million errands/month are $0)

Run the four commands above (the trust policy for the role is lesson 04's, verbatim — who may wear the hat: lambda.amazonaws.com). Invoke it five times fast; read the REPORT lines in the CloudWatch diary — spot the one cold start vs four warm ones, in milliseconds.

aws lambda delete-function --function-name hello   # tidy, as always

✅ Verify — what you should see

aws lambda invoke writes {"greeting": "hello, class 3A"}; the CloudWatch log group shows one cold Init Duration and four warm invocations.

🧹 Clean up — do not leave running

aws lambda delete-function --function-name hello — a million invocations are free, but tidy anyway

⚠️ Common mistakes

a 15-minute job in a 15-minute-capped helper
giving the execution role * — hats are least-privilege too
expecting state between invocations — helpers forget

⏭️ Next

You now rent desks, lockers, receptions, offices, and helpers. One skill left, and it's the one that keeps this hobby affordable: reading the meter. Lesson 20 — the bill.

← Previouscloudwatch Next →the bill

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