# Lambda
Lambda is a service that lets you run code without managing servers.
How it works:
1. You write a small piece of code (a function).
2. AWS Lambda runs it only when it’s needed (triggered by an event).
3. You pay only for the time the code runs, not for idle servers.
Analogy:
* Think of it like a coffee machine that turns on only when you press the button. You don’t keep it running all day—just use it when needed.
Example:
* When someone uploads a photo to your website, Lambda automatically resizes the image without you running a full server for it.
### **Stateless Vs Stateful**
1\. Stateless:
* The system doesn’t remember anything about past interactions.
* Every request is independent.
* Analogy: Like a vending machine—you put money and choose a snack, it doesn’t care what you did before.
* Example: Most web servers handling HTTP requests (each request is treated separately).
2\. Stateful:
* The system remembers past interactions and uses that info for the next request.
* Analogy: Like a video game save—your progress is remembered.
* Example: Online shopping cart (it remembers what items you added).
Key difference:
* Stateless = memoryless, simple, easier to scale.
* Stateful = remembers history, needed when context matters.
### **Lambda Networking Mode:**
By default, AWS Lambda is serverless and runs inside AWS’s own network. But sometimes your function needs to talk to things inside your VPC (Virtual Private Cloud) like RDS databases, EC2 instances, or private subnets.
Here’s how it works:
1\. Default (No VPC)
* Lambda has internet access (can call public APIs, S3, etc.).
* But it cannot access private resources inside your VPC.
👉 Example: Lambda can call `google.com` or AWS services, but not your private RDS database
2\. **With VPC Configuration**
* You connect Lambda to your VPC + subnets + security groups.
* Now it can talk to private resources (like RDS, EC2, ElastiCache).
* But ⚠️ by default, it loses internet access (because private subnets don’t have direct internet).
👉 Example: Lambda can query your private RDS database, but it can’t call `google.com` anymore.
3\. **Regaining Internet (NAT Gateway)**
* If your Lambda needs both private VPC resources and the internet, you place it in a private subnet with a NAT Gateway in a public subnet.
* This way it can reach the internet through NAT, and still talk to private resources.
**Security**
**Simple Analogy:**
* Think of Lambda as a delivery worker:
* Default = worker is outside (can go anywhere in the city = internet).
* Inside VPC = worker enters your company building (can only talk to people inside, no city access).
* NAT Gateway = a door with a security guard that lets the worker go outside to the city and come back.
✅ So, Lambda networking = choosing where Lambda runs (public vs private) and setting up routes (internet or private).
### **Lambda Invocation**
**Synchronous**
* Caller waits for the result.
* If Lambda fails, the caller sees the error.
* Examples:
* API Gateway calling Lambda (user clicks a button → expects immediate response).
* CLI/SDK calling Lambda directly.
* Analogy: Asking a waiter for water and standing there until they bring it.
**Asynchronous Invocation**
* Caller doesn’t wait. Lambda is triggered in the background.
* If it fails, AWS retries automatically.
* Examples:
* S3 event → upload a file → Lambda runs to process it.
* SNS (notifications) → triggers Lambda.
* Analogy: Ordering food online — you place the order and move on, the restaurant delivers later.
Idempotent An operation is idempotent if doing it once or many times gives the same result.
Examples
* Idempotent:
* Setting your password to `1234` → doing it again still results in `1234`.
* `DELETE /user/123` → deleting the same user again won’t bring them back; result is the same (user gone).
* Not Idempotent:
* Adding money to your bank account → if you repeat it, balance keeps increasing.
* `POST /order` → every request creates a new order (so multiple calls = multiple orders).
Analogy
* Idempotent: Turning off a light switch. Whether you flip it once or 10 times → the light stays off.
* Not Idempotent: Pressing a “dispense candy” button. Every press gives you more candy
✅ In AWS Lambda:\
You often want your functions to be idempotent, so if the same event is retried (like S3 triggering twice), the result doesn’t duplicate (e.g., no double watermarking on an image).
### **Event Source Mapping (Stream-based Invocation)**
* Lambda polls event sources like DynamoDB Streams, Kinesis, or SQS queues and processes records automatically.
* Analogy: A worker constantly checking a mailbox (queue) and processing new letters.
✅ So in short:
* Sync = Wait for answer
* Async = Fire and forget
* Event Source Mapping = Continuous polling from a queue/stream
### **Lambda version**
### **Lambda Runtime**
