Google Cloud Functions Nodes
Google Cloud Functions runs your own code behind an HTTPS trigger. MaestroHub provides two invocation nodes — one that waits for the response and one that does not — plus a discovery node that lists what is deployed. A function is named rather than pointed at by URL: the connector resolves the name through the Cloud Functions Admin API, so a redeployment that changes the URL does not break the pipeline.
Configuration Quick Reference
| Field | What you choose | Details |
|---|---|---|
| Parameters | Connection, Function, Function Parameters, Timeout Override | Select the connection profile, function, configure function parameters with expression support, and optionally override the per-call timeout. |
| Settings | Description, Timeout (seconds), Retry on Timeout, Retry on Fail, On Error | Node description, maximum execution time, retry behavior on timeout or failure, and error handling strategy. All execution settings default to pipeline-level values. |

Cloud Functions Invoke Node
Cloud Functions Invoke Node
Call a function over its HTTPS trigger and wait for the response. Use this when a downstream node needs what the function returns — a transform's output, an enrichment lookup, an inference result.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Invoke | Call a function and return its response | Serverless transforms, enrichment lookups, ML inference, calls into another project by URL |
How It Works
When the pipeline executes, the Invoke node:
- Resolves the configured Cloud Functions connection profile and loads credentials (a service account key or Application Default Credentials)
- Renders all templated fields (Function Name or URL, Payload) against the current pipeline context
- Resolves the function name to its HTTPS trigger through the Admin API, caching the answer for the life of the connection — a target that is already a
https://URL skips this step - Validates the body as JSON when Content Type says it is JSON, before any call is made
- Mints a Google-signed OIDC identity token whose audience is the function's own URL, unless the connection's Invocation Auth is
none - Calls the trigger with the configured method, body and headers, using the per-call timeout override or the connection default
- Decodes the response body as JSON when it parses, delivers it as text when it does not, and fails the node on a 4xx or 5xx answer
Configuration
| Field | What you choose | Details |
|---|---|---|
| Connection | Cloud Functions connection profile | Select a pre-configured connection from your connection library |
| Function | Invoke function | Choose a Cloud Functions Invoke function that defines the target, method, body and headers |
| Function Parameters | Call values | Configure dynamic values for Function Name or URL and Payload using expressions or constants |
| Timeout Override | Per-call timeout | Optional. Overrides the connection-level request timeout for this node only. A Go duration string between 1s and 60m (e.g. 30s). Leave empty to use the connection default. |
For detailed function configuration options — including the name-versus-URL choice, the response size cap, and how status codes map to node outcomes — see the Cloud Functions Invoke Function documentation.
A function that answers 400 or 500 has run and refused, so this node fails. Its error message carries the status code and a one-line summary of the response body; the failed node has no result.payload. The node's On Error setting decides what happens next: with Continue Execution the downstream nodes still run, but the failed node has no output for them to read (see Run status and On Error). A 4xx is treated as permanent — retrying the same body gets the same answer — while 5xx and 429 are retried.
If your function signals business outcomes with status codes, a 409 Conflict meaning "already processed" will fail the node. Answer 200 with a body the pipeline can branch on instead.
Cloud Functions are invoked by MaestroHub; they do not push events back. To have a function start a pipeline, give the pipeline a Webhook Trigger and POST to it from the function, or publish to a topic and use the Google Pub/Sub trigger.

Cloud Functions Invoke Async Node
Cloud Functions Invoke Async Node
Dispatch an invocation and return immediately, without waiting for the function to finish. Use this for side-effectful work that must not hold the pipeline up — a notification, an audit write, a downstream job.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| Invoke Async | Dispatch a call without waiting for it | Notifications, audit writes, queueing downstream jobs, handing off slow post-processing |
How It Works
When the pipeline executes, the Invoke Async node:
- Resolves the connection and the trigger URL exactly as the Invoke node does
- Builds the request on the connection's context rather than the pipeline's — the pipeline's is cancelled the moment this node returns, which is immediately
- Hands the request to a supervised background dispatch, bounded by the node's timeout
- Returns
{"dispatched": true}without waiting for the function
Configuration
| Field | What you choose | Details |
|---|---|---|
| Connection | Cloud Functions connection profile | Select a pre-configured connection from your connection library |
| Function | Invoke Async function | Choose a Cloud Functions Invoke Async function that defines the target and body |
| Function Parameters | Call values | Configure dynamic values for Function Name or URL and Payload using expressions or constants |
| Timeout Override | Dispatch bound | Optional. Caps how long the dispatched call may run in the background — not how long the pipeline waits. |
For detailed function configuration options see the Cloud Functions Invoke Async Function documentation.
Google offers no service-side queue for an HTTPS trigger, so unlike AWS Lambda's Event invocation type this is a genuine fire-and-forget. The function's response and any failure after dispatch are logged on the connection, not returned to the pipeline — a function that is down, slow, or rejects the payload still produces a successful node.
Because delivery cannot be confirmed, this operation is not eligible for store-and-forward. Use the Invoke node when the pipeline must know the work landed, or publish to Google Pub/Sub when a real queue is what you want.

Cloud Functions List Functions Node
Cloud Functions List Functions Node
List the functions the connection's credentials can see, with each one's HTTPS URL, generation, state and runtime.
Supported Function Types:
| Function Name | Purpose | Common Use Cases |
|---|---|---|
| List Functions | Discover deployed functions in a region, or across the project | Inventory audits, pre-flight checks before invoking, dispatch tables built by naming convention |
How It Works
When the pipeline executes, the List Functions node:
- Resolves the connection and builds the Admin API parent from the project and the region — the connection's, or the node's Region Override, where
-means every region - Pushes the page size, page token and filter down to the API as request parameters, so a small budget costs a small page rather than the project's whole inventory
- Returns one object per function, plus a continuation token when more remain and the list of regions the API could not reach
Configuration
| Field | What you choose | Details |
|---|---|---|
| Connection | Cloud Functions connection profile | Select a pre-configured connection from your connection library |
| Function | List Functions function | Choose a Cloud Functions List Functions function that defines the region, page size and filter |
| Function Parameters | Listing values | Configure dynamic values for Region Override, Filter and Page Token using expressions or constants |
| Timeout Override | Per-call timeout | Optional. A Go duration string between 1s and 1h. |
For detailed function configuration options see the Cloud Functions List Functions Function documentation.
A wildcard (-) listing can report a region the API could not reach. Its functions are simply missing from the result, so treat a non-empty unreachable as an incomplete inventory rather than a clean one — assert it is absent before acting on the list.
Output
Every Cloud Functions node delivers its data under result, and execution facts (success, functionId, durationMs, timestamp) under _metadata:
| Node | Expression | Description |
|---|---|---|
| Invoke | $node["Name"].result.payload | The function's response body, decoded from JSON, the raw string when it was not JSON, or null when the function returned nothing. Read a field with $node["Name"].result.payload.<field> |
$node["Name"].result.statusCode | The HTTP status the function answered with | |
| Invoke Async | $node["Name"].result.dispatched | true once the request is on its way. The function's own output and any failure after dispatch are logged on the connection, never delivered here |
| List Functions | $node["Name"].result.functions | One object per function: name, resourceName, url, state and environment, plus description, updateTime, runtime, serviceAccountEmail, availableMemory and timeoutSeconds when the API returned them. $node["Name"].result.functions[0].url reads the first one's trigger |
$node["Name"].result.count | How many functions this call returned | |
$node["Name"].result.nextPageToken | Where the listing stopped — present only when more functions remain. Pass it back as the node's Page Token to continue | |
$node["Name"].result.unreachable | Regions the API could not reach — present only when a wildcard listing hit one. Their functions are missing from this result | |
| Every node | $node["Name"]._metadata.method, $node["Name"]._metadata.connectionId, $node["Name"]._metadata.protocol | The call's other facts: the operation, the connection it ran over, and gcpfunctions |