Cloud Run Ephemeral Disk Is Not Persistent Storage
A temporary file can survive a request and still disappear with its instance. Use a small lifecycle experiment to choose where a Cloud Run result belongs.

Your application writes a report, serves it successfully, and finds it again on the next request. That still does not prove the report is durable.
The missing question is: did the second request reach the same instance? A file can survive several requests while remaining tied to an instance that the platform may later remove.
A disk solves a different problem from durability
Google’s Cloud Run release notes mark ephemeral disk as generally available on November 4, 2026. That makes it a timely option to evaluate for file-processing workloads. It does not change the meaning of ephemeral.
The configuration guide defines the volume around an instance’s lifetime. A local file is not automatically shared with other instances or preserved after that instance shuts down.
Consider a report pipeline:
| Data | What it needs | Useful question |
|---|---|---|
| Downloaded input copy | Temporary working space | Can the app download it again? |
| Intermediate expanded files | Space during processing | Can the task safely restart? |
| Finished report | A defined retention period | Where is the authoritative result stored? |
| Job status | A state another request can find | Does it exist outside one instance? |
The report’s size does not decide its storage class. Its recovery requirement does.
Watch the lifecycle with local directories
This small Python experiment uses temporary directories to model separate lifetimes. It does not emulate Cloud Run or test its deployment behavior.
from pathlib import Path
from tempfile import TemporaryDirectory
with TemporaryDirectory() as workspace:
durable = Path(workspace) / "saved-results"
durable.mkdir()
with TemporaryDirectory(dir=workspace) as instance_a:
scratch = Path(instance_a) / "report.txt"
scratch.write_text("report-v1\n")
print("same instance:", scratch.exists())
(durable / "report.txt").write_text(scratch.read_text())
with TemporaryDirectory(dir=workspace) as instance_b:
print("new instance:", (Path(instance_b) / "report.txt").exists())
print("separate result:", (durable / "report.txt").exists())
The tested output is:
same instance: True
new instance: False
separate result: True
The program explicitly removes the first instance directory and creates another. It shows why a request completing and an instance ending are different boundaries. The directory named saved-results is only separate local storage in this analogy; its name gives it no production durability guarantee.
Local Python simulation, November 5, 2026. No Google Cloud resources were deployed.
If container storage itself is unfamiliar, LabEx’s Docker volume activity provides useful prerequisites. The volume versus bind-mount experiment explores that local boundary; neither is a Cloud Run persistence test.
Make the result independent of a lucky request
For a real service, choose an appropriate durable store for the final result and define when the task is considered complete. A response saying “finished” should correspond to the result’s intended persistence contract, not merely to a successful write in scratch space.
Plan the failure path too. If the instance disappears during processing, can the request be retried? Can a retry identify an already completed result? Which intermediate files may safely be regenerated?
Do not rely on shutdown as the only opportunity to rescue the output. The configuration guide recommends incremental copying rather than depending on the brief shutdown grace period for the whole transfer.
Test the cloud behavior you actually depend on
In a disposable, authorized cloud project, record the instance identity alongside the test result. Check the durable result independently, and verify what happens when work is handled by another instance. A sequence of requests that happens to reuse one instance cannot establish cross-instance persistence.
Keep those observations separate from local tests. Before configuring a volume, recheck supported regions, limits, and billing in the current product documentation. The useful acceptance condition is specific: “the completed report remains retrievable from its intended store after the original instance is gone.”
References
- Cloud Run release notes: the November 4, 2026 GA entry.
- Configure ephemeral disk: volume lifetime and operational boundaries.
- Cloud Run container runtime contract: instance execution and shutdown behavior. Sources checked November 5, 2026.

