HTTP triggered functions in GCP - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ service_behavior

intermediate

HTTP Function Response Behavior

You deploy a Google Cloud Function triggered by HTTP. The function code is:

def hello_world(request):
    return 'Hello, World!'

What will the HTTP client receive as the response body?

GCP

def hello_world(request):
    return 'Hello, World!'

A The client receives an empty response with status code 204 (No Content).

B The client receives a JSON response with body '"Hello, World!"' and status code 200.

C The client receives a plain text response with body 'Hello, World!' and status code 200.

D The function raises an error because the return type is incorrect.

💡 Hint

Consider what happens when a string is returned directly from a Cloud Function.

Returning a string from a Python HTTP Cloud Function sends that string as the plain text response body with status 200.

❓ Configuration

intermediate

Setting HTTP Trigger Permissions

You want your HTTP triggered Cloud Function to be publicly accessible without authentication. Which IAM role should you grant to allUsers on the function?

A roles/cloudfunctions.invoker

B roles/cloudfunctions.admin

C roles/viewer

D roles/owner

💡 Hint

Think about the minimal permission needed to invoke a Cloud Function.

The roles/cloudfunctions.invoker role allows invoking the function. Granting it to allUsers makes the function public.

❓ Architecture

advanced

Designing Scalable HTTP Cloud Functions

You expect a sudden spike of HTTP requests to your Cloud Function. Which design choice helps ensure your function scales smoothly without cold start delays?

A Keep the function stateless and use minimum dependencies to reduce cold start time.

B Store session data in local memory inside the function instance.

C Use a single global variable to cache data across requests.

D Increase the function timeout to handle longer requests.

💡 Hint

Consider what causes cold starts and how to minimize their impact.

Stateless functions with minimal dependencies start faster and scale better. Local memory or global variables do not persist across instances reliably.

❓ security

advanced

Securing HTTP Cloud Functions with Authentication

You want to restrict your HTTP Cloud Function so only authenticated users from your Google Workspace domain can invoke it. What is the best approach?

A Grant roles/cloudfunctions.invoker to allUsers and rely on IP filtering.

B Make the function public and check the user's email in the request headers.

C Disable authentication and rely on a secret token passed as a query parameter.

D Require users to authenticate with Identity Platform and verify their ID token in the function code.

💡 Hint

Think about secure ways to verify user identity in Cloud Functions.

Using Identity Platform for authentication and verifying ID tokens ensures only authorized users can invoke the function securely.

✅ Best Practice

expert

Optimizing HTTP Cloud Function Cold Start Time

You notice your HTTP Cloud Function has high cold start latency due to large dependencies. Which option will most effectively reduce cold start time?

A Increase the function memory allocation to maximum to speed up startup.

B Use Cloud Functions Gen 2 with container-based deployment and optimize the container image size.

C Add a warm-up HTTP request every minute to keep the function instance alive.

D Rewrite the function in a slower language to reduce startup overhead.

💡 Hint

Consider newer Cloud Functions platforms and deployment methods.

Cloud Functions Gen 2 supports container images, allowing you to optimize dependencies and reduce cold start time effectively.

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