HTTP triggered functions in GCP - Step-by-Step Execution

Process Flow - HTTP triggered functions

Client sends HTTP request

↓

Cloud Function receives request

↓

Function executes code

↓

Function sends HTTP response

↓

Client receives response

This flow shows how an HTTP request from a client triggers a cloud function, which runs code and sends back a response.

Execution Sample

GCP

def hello_http(request):
    name = request.args.get('name', 'World')
    return f'Hello, {name}!'

A simple HTTP function that greets the user by name or says 'Hello, World!' if no name is given.

Process Table

Step	Action	Input	Processing	Output
1	Receive HTTP request	GET /?name=Alice	Parse query parameters	name = 'Alice'
2	Execute function	name = 'Alice'	Create greeting string	'Hello, Alice!'
3	Send HTTP response	'Hello, Alice!'	Return response body	HTTP 200 OK with body 'Hello, Alice!'
4	Client receives response	HTTP 200 OK	Display response	Shows 'Hello, Alice!' on client
5	Receive HTTP request	GET /	Parse query parameters	name = 'World' (default)
6	Execute function	name = 'World'	Create greeting string	'Hello, World!'
7	Send HTTP response	'Hello, World!'	Return response body	HTTP 200 OK with body 'Hello, World!'
8	Client receives response	HTTP 200 OK	Display response	Shows 'Hello, World!' on client

💡 Execution stops after sending HTTP response and client receives it.

Status Tracker

Variable	Start	After Step 1	After Step 2	After Step 6	Final
name	undefined	'Alice'	'Alice'	'World'	'World'
response	undefined	undefined	'Hello, Alice!'	'Hello, World!'	'Hello, World!'

Key Moments - 2 Insights

Why does the function use a default value 'World' for the name?

If the HTTP request has no 'name' parameter (see step 5), the function uses 'World' so it can still return a friendly greeting (see steps 6-8).

How does the function know what the client sent in the HTTP request?

The function reads the query parameters from the request object (step 1), extracting 'name' if present.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of 'name' after step 1 when the client sends GET /?name=Alice?

A 'Alice'

B 'World'

C undefined

D 'Hello, Alice!'

💡 Hint

Check the 'Input' and 'Processing' columns in row 1 of the execution table.

At which step does the function send the HTTP response back to the client?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look for the step where 'Send HTTP response' is the action in the execution table.

If the client sends GET / without a name parameter, what will the function output be?

A 'Hello, Alice!'

B An error message

C 'Hello, World!'

D Empty response

💡 Hint

Check steps 5 to 8 in the execution table and the variable_tracker for 'name' default.

Concept Snapshot

HTTP triggered functions run code when they get an HTTP request.
They read data from the request (like query parameters).
They process the data and send back an HTTP response.
If data is missing, they can use default values.
Clients see the response as a web page or message.

Full Transcript

An HTTP triggered function waits for a client to send an HTTP request. When the request arrives, the function reads any data sent, like a 'name' parameter. It then runs its code to create a response message. For example, it might say 'Hello, Alice!' if the name is Alice, or 'Hello, World!' if no name is given. The function sends this message back as an HTTP response. The client then shows this message. This process repeats for each request.

Practice

1. What happens when an HTTP triggered function in GCP receives a web request?

easy

A. The function only logs the request but does not respond.

B. The function stores the request without running any code.

C. The function runs the code and sends back a response.

D. The function waits for a manual trigger to run.

Solution

1. Step 1: Understand the trigger type

   HTTP triggered functions run automatically when they receive a web request.

2. Step 2: Identify the function behavior

   They process the request and return a response to the caller.

3. Final Answer:

   The function runs the code and sends back a response. -> Option C

4. Quick Check:

   HTTP trigger = runs code + responds [OK]

Hint: HTTP trigger means code runs on web request [OK]

Common Mistakes:

• Thinking the function only logs requests
• Assuming manual trigger is needed
• Believing the function stores requests without running

2. Which of the following is the correct way to define an HTTP triggered function in Python for GCP Cloud Functions?

easy

A. def my_function(data, context):

B. def my_function(event, context):

C. def my_function():

D. def my_function(request):

Solution

1. Step 1: Recall function signature for HTTP triggers

   HTTP triggered functions accept a single 'request' parameter representing the web request.

2. Step 2: Match the correct signature

   Only 'def my_function(request):' matches this pattern.

3. Final Answer:

   def my_function(request): -> Option D

4. Quick Check:

   HTTP function signature = def func(request) [OK]

Hint: HTTP functions take one 'request' parameter [OK]

Common Mistakes:

• Using event and context parameters (for background triggers)
• Defining function without parameters
• Using wrong parameter names

3. Given this Python HTTP function code snippet, what will be the HTTP response body when a GET request is made?

def hello_world(request):
    if request.method == 'GET':
        return 'Hello, World!'
    else:
        return 'Unsupported method', 405

medium

A. "Hello, World!"

B. "Unsupported method"

C. Error: Missing return statement

D. Empty response

Solution

1. Step 1: Check the request method

   The function checks if the request method is 'GET'.

2. Step 2: Determine response for GET

   For 'GET', it returns the string 'Hello, World!'.

3. Final Answer:

   "Hello, World!" -> Option A

4. Quick Check:

   GET request returns greeting [OK]

Hint: GET request returns 'Hello, World!' string [OK]

Common Mistakes:

• Confusing method names case sensitivity
• Expecting a JSON response without formatting
• Ignoring else branch

4. Identify the error in this HTTP triggered function code snippet:

def process_request(request):
    if request.method == 'POST'
        return 'Received POST'
    else:
        return 'Only POST allowed', 405

medium

A. Missing colon ':' after if statement

B. Incorrect return type for HTTP function

C. Wrong parameter name for request

D. No error in the code

Solution

1. Step 1: Check syntax of if statement

   The if statement is missing a colon ':' at the end.

2. Step 2: Confirm syntax error impact

   Without the colon, the code will cause a syntax error and fail to deploy.

3. Final Answer:

   Missing colon ':' after if statement -> Option A

4. Quick Check:

   if statement needs ':' [OK]

Hint: Check colons after if statements [OK]

Common Mistakes:

• Ignoring syntax errors
• Assuming return types are wrong
• Confusing parameter names

5. You want to create an HTTP triggered function that accepts JSON data in a POST request and returns the value of the 'name' field. Which code snippet correctly handles this in Python?

hard

A. def get_name(request):
data = request.get_json()
return f"Hello, {data.name}!"

B. def get_name(request):
data = request.get_json()
return f"Hello, {data['name']}!"

C. def get_name(request):
data = request.get_json
return f"Hello, {data['name']}!"

D. def get_name(request):
data = request.json()
return f"Hello, {data.name}!"

Solution

1. Step 1: Use correct method to parse JSON

   request.get_json() is the correct method to parse JSON body in GCP HTTP functions.

2. Step 2: Access JSON data correctly

   JSON data is a dictionary, so access fields with data['name'], not data.name.

3. Final Answer:

   def get_name(request): data = request.get_json() return f"Hello, {data['name']}!" -> Option B

4. Quick Check:

   Use get_json() and dict access [OK]

Hint: Use get_json() and dict keys for JSON data [OK]

Common Mistakes:

• Using request.json() instead of get_json()
• Accessing JSON fields with dot notation
• Forgetting parentheses on get_json