What's actually different between Cloud Functions Gen 1 and Gen 2, beyond just a version number?

Gen 2 Cloud Functions run on Cloud Run underneath — this isn't just an implementation detail, it directly changes concurrency behavior (Gen 2 can handle multiple concurrent requests per instance, unlike Gen 1's strictly one-request-per-instance model), maximum execution timeout (much longer for Gen 2), and how scaling and traffic splitting work, since Gen 2 inherits Cloud Run's actual capabilities rather than Gen 1's more limited, purpose-built execution model.

Gen 1 uses a dedicated, purpose-built execution model, strictly one concurrent request per instance: each Gen 1 function instance handles exactly one request at a time — if two requests arrive simultaneously, Cloud Functions spins up a second instance rather than routing both to the same one, which is simple to reason about but means concurrency scaling is entirely instance-count-driven.

Gen 2 runs on Cloud Run under the hood, inheriting its concurrency model: a Gen 2 function instance can handle multiple concurrent requests (configurable, up to a limit) — this is a genuinely different execution model, and code written assuming Gen 1's strict single-concurrency behavior (relying on global mutable state being safe because "only one request is ever in flight per instance") can have real concurrency bugs if migrated to Gen 2 without accounting for this.

Maximum execution timeout differs significantly: Gen 1 caps out at 9 minutes; Gen 2 supports up to 60 minutes for HTTP-triggered functions — this matters directly for any function doing genuinely long-running work, where Gen 1's shorter cap might force an awkward workaround (splitting work across multiple invocations) that Gen 2's longer timeout simply doesn't require.

Gen 2 gets Cloud Run's traffic management capabilities, like traffic splitting between revisions: since Gen 2 functions are actually Cloud Run services underneath, they inherit Cloud Run's ability to split traffic between multiple revisions (useful for gradual rollouts/canary-style deployment) — Gen 1 doesn't have an equivalent built-in mechanism.

Migrating from Gen 1 to Gen 2 isn't purely transparent — it requires validating the concurrency assumption specifically: the single most important thing to check when migrating an existing Gen 1 function to Gen 2 is whether its code makes any assumption that only one request is ever active at a time in a given instance (unprotected shared mutable state, for instance) — this assumption, safe under Gen 1, becomes a real concurrency bug under Gen 2's default concurrent-request handling unless explicitly addressed (either fixing the code to be concurrency-safe, or explicitly configuring the Gen 2 function's concurrency to 1 to preserve Gen 1's behavior).

• Gen 2 runs on Cloud Run under the hood, which is the root cause of essentially every behavioral difference from Gen 1, not just a version bump.
• Gen 1 handles strictly one request per instance; Gen 2 can handle multiple concurrent requests per instance by default, which can expose concurrency bugs in code written assuming Gen 1's model.
• Gen 2 supports a much longer maximum execution timeout (60 minutes vs. Gen 1's 9 minutes) for HTTP-triggered functions.
• Migrating from Gen 1 to Gen 2 requires explicitly validating (or fixing, or configuring concurrency=1 to preserve) any code that assumed single-request-at-a-time execution.

• Google Cloud: Cloud Functions versions comparison