HTTP triggered functions in GCP - Commands & Configuration

Introduction

Sometimes you want your code to run only when someone visits a web address or sends a web request. HTTP triggered functions let you do this easily by running your code when an HTTP request happens.

When you want to create a simple web API that runs your code on demand.

When you need to respond to webhooks from other services like payment or messaging platforms.

When you want to build a lightweight backend for a web or mobile app without managing servers.

When you want to quickly test or run code by visiting a URL in your browser.

When you want to handle form submissions or user input sent over the web.

Config File - main.py

main.py

def hello_world(request):
    """HTTP Cloud Function.
    Args:
        request (flask.Request): The request object.
    Returns:
        A response string.
    """
    return 'Hello, World!'

This Python file defines a simple HTTP triggered function named hello_world. It takes a web request and returns a plain text response saying 'Hello, World!'. This function runs whenever an HTTP request is sent to its URL.

Commands

This command deploys the HTTP triggered function named 'hello_world' using Python 3.9 runtime. It sets the function to run when it receives an HTTP request and allows anyone to call it without signing in.

Terminal

gcloud functions deploy hello_world --runtime python39 --trigger-http --allow-unauthenticated

Expected Output

Deploying function (may take a while)...



Deploying function (hello_world)...done.



availableMemoryMb: 256

entryPoint: hello_world

httpsTrigger:

  url: https://REGION-PROJECT_ID.cloudfunctions.net/hello_world

runtime: python39

serviceAccountEmail: [e-mail]

status: ACTIVE

timeout: 60s

updateTime: '2024-06-01T12:00:00Z'

versionId: '1'

→

--runtime - Specifies the language runtime version to use

→

--trigger-http - Sets the function to be triggered by HTTP requests

→

--allow-unauthenticated - Allows public access without requiring login

This command sends a simple HTTP GET request to the deployed function's URL to test if it responds correctly.

Terminal

curl https://REGION-PROJECT_ID.cloudfunctions.net/hello_world

Expected Output

Hello, World!

Key Concept

If you remember nothing else from this pattern, remember: HTTP triggered functions run your code whenever someone sends a web request to their URL.

Common Mistakes

Not using the --trigger-http flag when deploying the function

Without this flag, the function won't respond to HTTP requests and won't have a public URL.

Always include --trigger-http when deploying functions meant to respond to web requests.

Forgetting to add --allow-unauthenticated for public access

Without this flag, only authenticated users can call the function, blocking public access.

Add --allow-unauthenticated if you want anyone to access the function without signing in.

Not returning a response from the function

If the function does not return a response, the caller will get an error or no output.

Make sure your function returns a string or valid HTTP response.

Summary

Deploy the function with gcloud using --trigger-http and --allow-unauthenticated flags.

Test the function by sending an HTTP request to its URL using curl.

The function runs your code and returns a response whenever it receives an HTTP 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