Lambda with API Gateway pattern in AWS - Step-by-Step Execution

Process Flow - Lambda with API Gateway pattern

Client sends HTTP request

↓

API Gateway receives request

↓

API Gateway triggers Lambda function

↓

Lambda function executes code

↓

Lambda returns response to API Gateway

↓

API Gateway sends HTTP response to client

This flow shows how a client request goes through API Gateway to trigger a Lambda function, which processes and returns a response back through API Gateway to the client.

Execution Sample

AWS

import json

def lambda_handler(event, context):
    name = event.get('queryStringParameters', {}).get('name', 'World')
    return {
        'statusCode': 200,
        'body': json.dumps({'message': f'Hello, {name}!'})
    }

A simple Lambda function triggered by API Gateway that reads a 'name' query parameter and returns a greeting message.

Process Table

Step	Action	Input	Lambda Processing	Output
1	Client sends HTTP GET request	GET /?name=Alice	N/A	Request received by API Gateway
2	API Gateway triggers Lambda	Event with queryStringParameters={'name':'Alice'}	Reads 'name' parameter	Prepares greeting message
3	Lambda executes	{'queryStringParameters': {'name': 'Alice'}}	Creates message 'Hello, Alice!'	{'statusCode': 200, 'body': '{"message": "Hello, Alice!"}'}
4	API Gateway sends response	Lambda output	N/A	HTTP 200 with body '{"message": "Hello, Alice!"}' sent to client
5	Client receives response	HTTP 200 with body	N/A	Displays message 'Hello, Alice!'
6	Client sends HTTP GET request	GET / (no name)	N/A	Request received by API Gateway
7	API Gateway triggers Lambda	Event with queryStringParameters=None	Uses default 'World'	Prepares greeting message
8	Lambda executes	{'queryStringParameters': None}	Creates message 'Hello, World!'	{'statusCode': 200, 'body': '{"message": "Hello, World!"}'}
9	API Gateway sends response	Lambda output	N/A	HTTP 200 with body '{"message": "Hello, World!"}' sent to client
10	Client receives response	HTTP 200 with body	N/A	Displays message 'Hello, World!'
11	No more requests	N/A	N/A	Execution ends

💡 Execution stops after client receives response and no further requests are made.

Status Tracker

Variable	Start	After Step 2	After Step 3	After Step 7	After Step 8	Final
event	N/A	{'queryStringParameters': {'name': 'Alice'}}	{'queryStringParameters': {'name': 'Alice'}}	{'queryStringParameters': None}	{'queryStringParameters': None}	N/A
name	N/A	'Alice'	'Alice'	'World'	'World'	N/A
response	N/A	N/A	{'statusCode': 200, 'body': '{"message": "Hello, Alice!"}'}	N/A	{'statusCode': 200, 'body': '{"message": "Hello, World!"}'}	N/A

Key Moments - 3 Insights

Why does the Lambda function use 'World' when no 'name' parameter is provided?

When the event's 'queryStringParameters' is None or missing 'name', the code uses a default value 'World' as shown in steps 7 and 8 in the execution_table.

How does API Gateway pass the HTTP request data to Lambda?

API Gateway converts the HTTP request into an event object with details like 'queryStringParameters' and passes it to Lambda, as seen in steps 2 and 7.

What happens if Lambda returns a statusCode other than 200?

API Gateway will forward that status code in the HTTP response to the client, affecting how the client interprets the result. This is implied in step 4.

Visual Quiz - 3 Questions

Look at the execution_table at step 3. What is the value of 'name' inside Lambda?

A 'Alice'

B 'World'

C None

D 'Bob'

💡 Hint

Check the 'Lambda Processing' column at step 3 in the execution_table.

At which step does the Lambda function use the default name 'World'?

A Step 3

B Step 8

C Step 2

D Step 5

💡 Hint

Look for where 'Uses default "World"' appears in the execution_table.

If the client sends a request with '?name=Bob', what will the Lambda's response message be?

A 'Hello, Alice!'

B 'Hello, World!'

C 'Hello, Bob!'

D An error message

💡 Hint

Refer to how the Lambda reads the 'name' parameter in the variable_tracker and execution_table.

Concept Snapshot

Lambda with API Gateway pattern:
- API Gateway receives HTTP request
- Passes event to Lambda function
- Lambda reads event data (e.g., query parameters)
- Lambda returns response with statusCode and body
- API Gateway sends HTTP response to client
- Default values used if parameters missing

Full Transcript

This visual execution shows how a client sends an HTTP request to API Gateway, which triggers a Lambda function. The Lambda function reads the query parameter 'name' from the event. If 'name' is missing, it defaults to 'World'. The Lambda returns a JSON message greeting the name. API Gateway sends this response back to the client. The execution table traces each step from request to response, showing variable values and actions. Key moments clarify default values and data passing. The quiz tests understanding of variable values and flow.

Practice

1. What is the primary role of AWS API Gateway when used with Lambda in a serverless architecture?

easy

A. To receive HTTP requests and trigger Lambda functions

B. To store data permanently

C. To run long-running background tasks

D. To manage virtual machines

Solution

1. Step 1: Understand API Gateway's function

   API Gateway acts as a front door to accept and process HTTP requests from clients.

2. Step 2: Connect API Gateway to Lambda

   API Gateway triggers Lambda functions to execute backend logic upon receiving requests.

3. Final Answer:

   To receive HTTP requests and trigger Lambda functions -> Option A

4. Quick Check:

   API Gateway triggers Lambda = A [OK]

Hint: API Gateway handles HTTP, Lambda runs code [OK]

Common Mistakes:

• Confusing API Gateway with data storage
• Thinking Lambda manages servers
• Assuming API Gateway runs background tasks

2. Which of the following is the correct way to configure an API Gateway method to trigger a Lambda function?

easy

A. Set the integration type to HTTP and specify the Lambda URL

B. Set the integration type to VPC Link and attach Lambda

C. Set the integration type to Lambda Function and select the function ARN

D. Set the integration type to MOCK and provide Lambda code inline

Solution

1. Step 1: Identify correct integration type

   API Gateway uses 'Lambda Function' integration to directly invoke Lambda functions.

2. Step 2: Specify Lambda function ARN

   You must provide the ARN (Amazon Resource Name) of the Lambda function to link it properly.

3. Final Answer:

   Set the integration type to Lambda Function and select the function ARN -> Option C

4. Quick Check:

   Integration type Lambda Function + ARN = D [OK]

Hint: Use 'Lambda Function' integration with ARN [OK]

Common Mistakes:

• Using HTTP integration instead of Lambda Function
• Confusing MOCK integration with Lambda
• Incorrectly using VPC Link for Lambda

3. Consider this AWS Lambda function triggered by API Gateway:

exports.handler = async (event) => {
  return { statusCode: 200, body: JSON.stringify({ message: event.queryStringParameters.name }) };
};

What will be the response body if the API Gateway is called with URL ?name=Alice?

medium

A. {"message":"Alice"}

B. {"message":null}

C. {"message":"name"}

D. Error: event.queryStringParameters undefined

Solution

1. Step 1: Understand event object from API Gateway

   API Gateway passes query parameters inside event.queryStringParameters, so event.queryStringParameters.name equals 'Alice'.

2. Step 2: Check Lambda return value

   Lambda returns JSON string with message key set to 'Alice', so response body is '{"message":"Alice"}'.

3. Final Answer:

   {"message":"Alice"} -> Option A

4. Quick Check:

   Query param 'name=Alice' -> message = 'Alice' [OK]

Hint: Query params in event.queryStringParameters [OK]

Common Mistakes:

• Assuming queryStringParameters is null
• Returning raw object instead of JSON string
• Confusing parameter name with literal string

4. You deployed an API Gateway with Lambda integration but receive a 502 Bad Gateway error when calling the API. What is the most likely cause?

medium

A. API Gateway endpoint URL is incorrect

B. Lambda function is not returning a properly formatted response

C. Lambda function has no execution role assigned

D. API Gateway method is set to MOCK integration

Solution

1. Step 1: Understand 502 Bad Gateway meaning

   502 error usually means API Gateway received an invalid response from Lambda.

2. Step 2: Check Lambda response format

   Lambda must return an object with statusCode and body as string; missing or malformed response causes 502.

3. Final Answer:

   Lambda function is not returning a properly formatted response -> Option B

4. Quick Check:

   502 error = bad Lambda response format [OK]

Hint: 502 means Lambda response format error [OK]

Common Mistakes:

• Assuming wrong API Gateway URL causes 502
• Ignoring Lambda execution role issues (causes 403)
• Confusing MOCK integration with Lambda integration

5. You want to design a serverless API using API Gateway and Lambda that handles high traffic with unpredictable spikes. Which design choice best ensures scalability and cost efficiency?

hard

A. Use API Gateway with Lambda proxy integration and enable Lambda reserved concurrency

B. Use API Gateway with HTTP integration to EC2 instances behind an autoscaling group

C. Use API Gateway with MOCK integration and pre-warm Lambda functions manually

D. Use API Gateway with Lambda proxy integration and rely on Lambda's default scaling without reserved concurrency

Solution

1. Step 1: Understand Lambda scaling behavior

   Lambda scales automatically with incoming requests without needing reserved concurrency unless limiting concurrency is required.

2. Step 2: Evaluate cost and scalability

   Relying on default Lambda scaling avoids paying for reserved concurrency and handles unpredictable spikes efficiently.

3. Step 3: Compare other options

   EC2 autoscaling adds server management and cost; MOCK integration doesn't run real code; reserved concurrency limits scaling.

4. Final Answer:

   Use API Gateway with Lambda proxy integration and rely on Lambda's default scaling without reserved concurrency -> Option D

5. Quick Check:

   Default Lambda scaling + proxy integration = C [OK]

Hint: Default Lambda scaling handles spikes best [OK]

Common Mistakes:

• Setting reserved concurrency unnecessarily limits scaling
• Using EC2 adds complexity and cost
• Using MOCK integration doesn't run Lambda code