Cloud Run Jobs 是什麼?它專跑「做完就結束」的工作:沒有網址,手動或排程執行,可拆成多個 task 一起跑。
第 20 篇把網頁部署成 Cloud Run 服務,第 22 篇算過服務的帳單。但不是每個程式都是網站:每天凌晨產報表、把一批檔案轉檔、搬一次資料,這種「跑完就收工」的工作,硬塞成服務反而麻煩。這篇把 Cloud Run 裡三種最常用的跑法放在一起比:服務、Jobs、functions。
這篇會在同一個專案實際跑一次:建一個 Cloud Run Job,把 9 個檔案分給 3 個 task 一起處理,故意讓其中一個失敗看它自動重試,再用 Cloud Scheduler 排程;最後只寫一段 Python 函式部署成 Cloud Run function,看它為什麼「其實就是一個服務」。
這是「容器系列」第 23 篇。全部在 Cloud Shell 實際跑過,輸出都是真實結果(2026 年 11 月實測,Google Cloud SDK 592.0.0)。上限、價格是 2026 年 11 月查官方文件的數字,以後可能調整。

為什麼你需要知道
- 選錯會多寫很多程式:把每天跑一次的批次工作做成服務,要自己寫一個網址讓排程去叫它、還要擔心請求 60 分鐘的上限;做成 Job 就不用
- 選錯也會多付錢:服務開了最小執行個體,沒人用也收閒置費(第 22 篇算過一個月約 9.72 美元);Job 跑完就關機,只收跑的那段時間
- 名字改過好幾次:Cloud Functions 現在叫 Cloud Run functions,網路上新舊教學混在一起,指令也不一樣(這篇有對照表)
- 面試和證照很愛考:「每天晚上處理一批檔案」「收到上傳就處理」「要一個 API」這三種情境,答案分別是 Jobs、functions(或服務)、服務
Cloud Run 有哪幾種跑法:先看全貌
Cloud Run 是 Google Cloud 的全代管容器平台:你交出映像檔或程式碼,它負責開機器、擴展、關機。 官方文件把 Cloud Run 的資源分成四種,functions 不是第五種,它部署完會變成一個服務(2026 年 11 月查官方概覽):
| 資源 | 白話 | 有沒有網址 | 怎麼開始跑 |
|---|---|---|---|
| 服務(Service) | 開著門等客人的店 | 有,run.app 網址 | 有請求或事件進來 |
| Jobs(工作) | 接案做完就收工的工班 | 沒有 | 手動、排程、工作流程 |
| worker pools | 一直在後台做事的員工 | 沒有 | 部署完就一直跑 |
| instances(Preview) | 一台長期開著的單機 | 有,每台一個網址 | 建立就開著 |
| functions | 只寫一段函式,Cloud Run 幫你包成服務 | 有 | HTTP 或事件 |
Preview(預覽版)是 Google 還在測試、沒有正式承諾穩定度的功能,正式環境先別用。這篇的重點是前三個最常用的:服務、Jobs、functions,worker pools 和 instances 在後面各用一段帶過。
容器是把程式和它需要的東西打包在一起的執行環境,第 1 篇有完整說明;映像檔是容器的打包檔。這三種跑法底下都是同一套容器執行環境,差別在「什麼時候開始、什麼時候結束、怎麼計費」。
Cloud Run 服務是什麼:開著門等客人
Cloud Run 服務(Service)是一個有固定 HTTPS 網址的程式:有人連進來才處理,沒人用時可以縮到 0 台,處理完一個請求不會結束,會繼續等下一個。
- 比喻:便利商店。門一直開著,客人(請求)進來就結帳,沒客人時店員可以去休息(縮到 0),但店不會關
- 來龍去脈:網站、API 這類程式要「隨時有人能連」,所以 Cloud Run 最早就是為這種程式設計的,第 20 篇完整做過一次
- 為什麼要學:它是 Cloud Run 的預設用法,其他兩種都是拿它來對照
HTTPS 網址是瀏覽器能連的加密網址。請求(Request)是有人連進來要一個網頁或資料的那一次。服務的一個請求預設最多處理 5 分鐘,最多可以調到 60 分鐘,超過就回錯誤(2026 年 11 月查官方逾時說明)。這個上限就是「長時間的批次工作不適合做成服務」的原因之一。
Cloud Run Jobs 是什麼:接案做完就收工
Cloud Run Jobs 是 Cloud Run 跑「做完就結束」程式的方式:沒有網址、不聽請求,執行一次就把程式跑到結束,可以把工作拆成多個 task 一起跑,失敗會自動重試。
- 比喻:搬家公司。你下一張工單(Job),約一天執行(Execution),公司派 3 個工人(Task)分頭搬,搬完就收工回家,不會在你家待著等下一單
- 來龍去脈:如果只有服務可用,跑批次工作就得包成網站、寫一個網址讓排程來叫,還會被一個請求最多 60 分鐘的上限卡住。Jobs 就是專門處理這種「跑完就結束」的工作,不用網址,一個 task 可以跑到 168 小時
- 為什麼要學:每天產報表、資料庫遷移、整批轉檔、機器學習的批次預測,實務上大量工作都是這一種
批次(Batch)是把一堆資料累積起來、一次處理完的做法,跟「來一個處理一個」的網站相反。官方中文文件把 Jobs 譯成「工作」,Task 也常被譯成「工作」,容易混在一起,這篇保留英文。
三個名詞:Job、Execution、Task
| 名詞 | 白話 | 這篇的例子 |
|---|---|---|
| Job | 工單:寫好用哪個映像檔、幾個 task、重試幾次 | ct-job:3 個 task、重試 1 次 |
| Execution | 執行一次就產生一筆,像這張工單的一次出勤 | ct-job-95nmw、ct-job-thw2p |
| Task | 一個執行中的容器,像一個工人 | task 0、1、2 |
每個 task 啟動時,Cloud Run 會給它幾個環境變數(Environment variable,程式啟動時可以讀到的設定值),程式靠它們知道「我是第幾個工人」(2026 年 11 月查容器執行合約):
| 環境變數 | 意思 | 例子 |
|---|---|---|
CLOUD_RUN_TASK_INDEX | 我是第幾個 task,從 0 開始 | 0、1、2 |
CLOUD_RUN_TASK_COUNT | 這次總共幾個 task | 3 |
CLOUD_RUN_TASK_ATTEMPT | 這是第幾次嘗試,從 0 開始,重試會加 1 | 0、1 |
CLOUD_RUN_EXECUTION | 這次 Execution 的名字 | ct-job-thw2p |

Jobs 的重要設定與上限
| 設定 | gcloud 參數 | 預設 | 上限 |
|---|---|---|---|
| task 數量 | --tasks | 1 | 10,000 |
| 同時跑幾個 | --parallelism | 盡量全部一起跑 | 看區域和規格 |
| 每個 task 失敗重試幾次 | --max-retries | 3 | 10 |
| 每個 task 最多跑多久 | --task-timeout | 10 分鐘 | 168 小時(7 天),用 GPU 是 12 小時 |
(2026 年 11 月查官方建立 Jobs 說明和配額與上限)
重試是每個 task 各自算,不是整個 Job 一起重來。只要有任何一個 task 把重試次數用完還失敗,整個 Execution 就算失敗。整個 Execution 本身沒有時間上限,所有 task 都跑完就結束。
Cloud Run functions 是什麼:只寫一段函式
Cloud Run functions 是只要寫一段函式、不用寫 Dockerfile,Cloud Run 就幫你打包成映像檔、部署成服務的做法;以前叫 Cloud Functions。
- 比喻:自動販賣機。你只決定「投錢後要掉出哪一瓶」(函式內容),機器的外殼、電路、投幣孔都由廠商做好
- 來龍去脈:Google 先推出 Cloud Functions,讓人只寫函式就能上線。第二代(2nd gen)底層其實已經是 Cloud Run,2024 年 8 月起可以直接用 Cloud Run 部署和管理這些函式,產品也改名 Cloud Run functions(2026 年 11 月查官方比較頁)
- 為什麼要學:網路上「Cloud Functions 教學」很多,指令和名稱跟現在不一樣,不知道新舊對照會照著舊文章卡住
函式(Function)是一段有名字、收到輸入就回傳結果的程式碼,例如收到一個名字、回傳一句問候。Dockerfile 是告訴 Docker 怎麼打包映像檔的說明書,第 4 篇寫過。
新舊名稱與指令對照
| 現在(Cloud Run functions) | 第一代(1st gen) | |
|---|---|---|
| 以前叫 | Cloud Functions(2nd gen) | Cloud Functions(1st gen) |
| 底層 | 一個 Cloud Run 服務 | Google 內部平台 |
| 官方建議的部署指令 | gcloud run deploy --function | gcloud functions deploy --no-gen2 |
| 也能用 | gcloud functions deploy(Cloud Functions v2 API) | |
| 網址 | run.app | cloudfunctions.net |
| 一個 HTTP 請求最多 | 60 分鐘 | 9 分鐘 |
| 一台同時處理幾個請求 | 最多 1,000 | 1 |
| 計費 | 照 Cloud Run 定價 | 第一代自己的定價 |
(2026 年 11 月查官方比較頁)
官方現在建議用 gcloud run deploy --function 建函式。要注意:用這個方式建的函式,只能用 Cloud Run 的工具管理,不能再用 gcloud functions 指令改。站上Cloud Run Functions 簡介有 Console 介面的操作,這篇用指令做。
一張表比較:服務、Jobs、functions
| 服務 | Jobs | functions | |
|---|---|---|---|
| 怎麼開始跑 | HTTP 請求、事件 | 手動、Cloud Scheduler 排程、工作流程 | HTTP 請求、事件(Eventarc) |
| 有沒有網址 | 有 | 沒有 | 有 |
| 什麼時候結束 | 不結束,等下一個請求 | 程式跑完就結束 | 同服務 |
| 單次上限 | 一個請求 60 分鐘 | 一個 task 168 小時 | HTTP 60 分鐘,事件 9 分鐘(v2 API 建的) |
| 平行處理 | 自動擴展台數 | 最多 10,000 個 task | 自動擴展台數 |
| 失敗重試 | 服務本身不重試,由呼叫的一方決定 | 每個 task 自動重試,預設 3 次 | 事件觸發可在 Eventarc 設重試 |
| 計費 | 預設以請求計費 | 一律以執行個體計費,每台最少 1 分鐘 | 同服務,另加建置費 |
| 要不要 Dockerfile | 要(或用原始碼部署) | 要(或用原始碼部署) | 不用 |
| 適合 | 網站、API、Webhook | 報表、轉檔、資料遷移、批次預測 | 小型 API、收到檔案或訊息就處理 |
Eventarc 是 Google Cloud 的事件轉送服務:例如有人把檔案上傳到 Cloud Storage,它就通知你的函式或服務來處理。Webhook 是別的系統在某件事發生時,主動打你的網址通知你。

worker pools 和 instances:一段帶過
worker pools 是沒有網址、不聽 HTTP 請求、一直在背景做事的 Cloud Run 資源,適合從 Pub/Sub、Kafka 這類訊息佇列一直拉工作出來處理。它不會自動擴展,台數要自己設,或用官方的 CREMA 依佇列長度調整;最小台數設 0 就完全不會啟動(2026 年 11 月查官方概覽)。台灣 asia-east1 的單價是每 vCPU 秒 0.000011244 美元、每 GiB 秒 0.000001235 美元,比服務的以執行個體計費(0.000018、0.000002)便宜約 38%(2026 年 11 月用 Cloud Billing Catalog API 查)。訊息佇列是什麼,可以看Cloud Pub/Sub 教學。
instances 是一台長期開著、有自己網址的單機,官方舉的例子是長時間執行的 AI 代理程式、開發用環境,建立約 20 秒內就能用。2026 年 11 月還是 Preview。
算一次:Cloud Run Jobs 怎麼收費
Cloud Run Jobs 一律以執行個體計費:每個 task 從開機到結束整段時間都算錢,每台最少算 1 分鐘,不收請求費(2026 年 11 月查官方定價頁)。台灣 asia-east1 的單價和每月免費額度:
| 項目 | 單價(asia-east1) | 每月免費額度 |
|---|---|---|
| CPU | 每 vCPU 秒 0.000018 美元 | 24 萬 vCPU 秒 |
| 記憶體 | 每 GiB 秒 0.000002 美元 | 45 萬 GiB 秒 |
vCPU 秒是 1 顆虛擬 CPU 用 1 秒,GiB 秒是 1 GiB 記憶體用 1 秒,第 22 篇有詳細說明。單價跟服務的「以執行個體計費」一樣(用 Cloud Billing Catalog API 交叉確認)。
假設一:每天凌晨跑一次報表,每次 10 個 task、每個跑 5 分鐘,規格 1 vCPU、512 MiB(0.5 GiB):
- 一個月:30 次 × 10 個 × 300 秒 = 9 萬 vCPU 秒
- 記憶體:9 萬 × 0.5 = 4.5 萬 GiB 秒
- 都在免費額度內,0 美元
假設二:同樣的 Job 改成每小時跑一次(一個月 30 × 24 = 720 次):
- CPU:720 × 10 × 300 = 216 萬 vCPU 秒,扣免費 24 萬 = 192 萬 × 0.000018 = 34.56 美元
- 記憶體:216 萬 × 0.5 = 108 萬 GiB 秒,扣免費 45 萬 = 63 萬 × 0.000002 = 1.26 美元
- 合計:約 35.82 美元
數字變大會怎樣:跑的次數、task 數、每個 task 的時間,任何一個變 2 倍,帳單(扣掉免費額度的部分)大約也變 2 倍。反過來,task 只跑 5 秒也算 1 分鐘:這篇實作的 task 每個只跑約 5 秒,一樣照 60 秒算,所以很短的工作拆成太多 task 會吃虧。
延後執行(Delayed Jobs):不急的工作可以用 gcloud beta run jobs execute --delay-execution,同意最多延後 12 小時才開始跑,asia-east1 單價降到每 vCPU 秒 0.0000126 美元、每 GiB 秒 0.0000014 美元,約便宜 3 成。官方註明延後執行的價格是動態的,最多每 30 天調整一次(2026 年 11 月查執行 Jobs 說明)。
Cloud Scheduler 另外算:每個排程每 31 天 0.10 美元,每個帳單帳戶每月前 3 個免費(2026 年 11 月查Cloud Scheduler 定價頁)。
動手做:建一個 Cloud Run Job,再部署一個 function
這段在 Cloud Shell,專案 dong-dong-gcp-3(換成你自己的專案)做,大約 20 分鐘。用量都在免費額度內,做完照「用完記得刪」清掉。
Cloud Shell 怎麼打開請看第 1 篇的步驟,畫面上方要先選好你的專案。截圖裡的提示字元有縮短,你的畫面會是「你的帳號@cloudshell:~ (你的專案ID)$」。有些指令後面接了 sed,是把輸出裡的 Gmail 帳號換成「你的帳號」,你自己做可以不加。
整篇請在同一個 Cloud Shell 分頁做完,中間存的變數(REPO、EXEC、PROJECT)關掉分頁就不見了。
步驟 1:確認專案、開啟 API
gcloud config get-value project; gcloud services enable run.googleapis.com artifactregistry.googleapis.com cloudbuild.googleapis.com cloudscheduler.googleapis.com && echo API OK
Your active configuration is: [cloudshell-7419]
dong-dong-gcp-3
Operation "operations/acat.p2-600195576280-25c4e1a4-d1f0-427d-b9ea-5c3a7c579cae" finished successfully.
API OK

API 是 Google Cloud 每個服務對外的開關,要先打開才能用。這次多開兩個:Cloud Build(function 要靠它打包,第 21 篇介紹過)和 Cloud Scheduler(排程)。
步驟 2:寫一個「做完就結束」的程式
這個程式模擬「處理 9 個報表檔」:每個 task 讀自己的 CLOUD_RUN_TASK_INDEX,只挑屬於自己的 3 個檔案,等 5 秒假裝在處理,印出 done 就結束。另外留一個開關:環境變數 FAIL_TASK 等於自己的編號、而且是第一次嘗試時,就故意失敗。
用 cat > 檔名 <<'EOF' 一次建好兩個檔案(整段複製貼上,按 Enter):
mkdir -p ~/ct-jobs/job && cd ~/ct-jobs/job
cat > job.py <<'EOF'
import os
import sys
import time
index = int(os.environ.get("CLOUD_RUN_TASK_INDEX", 0))
count = int(os.environ.get("CLOUD_RUN_TASK_COUNT", 1))
attempt = int(os.environ.get("CLOUD_RUN_TASK_ATTEMPT", 0))
files = [f"report-{n:02d}.csv" for n in range(1, 10)]
mine = files[index::count]
print(f"task {index}/{count} attempt {attempt}: {len(mine)} files {mine}")
if os.environ.get("FAIL_TASK") == str(index) and attempt == 0:
print(f"task {index}: simulated error, exit 1")
sys.exit(1)
time.sleep(5)
print(f"task {index}: done")
EOF
cat > Dockerfile <<'EOF'
FROM python:3.14-slim
WORKDIR /app
COPY job.py .
CMD ["python", "job.py"]
EOF
ls
Dockerfile job.py

files[index::count]是 Python 的切片:從第index個開始,每隔count個拿一個。3 個 task 時,task 0 拿第 1、4、7 個,task 1 拿第 2、5、8 個,task 2 拿第 3、6、9 個,剛好分完不重複sys.exit(1)讓程式用結束代碼(Exit code)1 結束。結束代碼是程式結束時回報的數字:0 代表成功,不是 0 代表失敗,Cloud Run 靠它判斷要不要重試- 跟服務不一樣的地方:這個程式沒有聽任何 Port,印完就結束。服務的程式如果結束,Cloud Run 會當成壞掉
步驟 3:建存放區、建映像檔並推上去
gcloud artifacts repositories create ct-demo --repository-format=docker --location=asia-east1 2>&1 | tail -1; REPO=asia-east1-docker.pkg.dev/$(gcloud config get-value project 2>/dev/null)/ct-demo; docker build -q -t $REPO/ct-job:v1 . && docker push -q $REPO/ct-job:v1
Created repository [ct-demo].
sha256:806a77390d62e289c0d8bbb0f61b147c58a648c6a7198f809b6627954ac6ac83
asia-east1-docker.pkg.dev/dong-dong-gcp-3/ct-demo/ct-job:v1

存放區、docker push 的細節在第 19 篇 Artifact Registry。-q 是安靜模式,只印結果。
步驟 4:建立 Cloud Run Job
time gcloud run jobs create ct-job --image=$REPO/ct-job:v1 --region=asia-east1 --tasks=3 --max-retries=1 --task-timeout=2m
Creating Cloud Run job [ct-job] in project [dong-dong-gcp-3] region [asia-east1]
Creating job...
Done.
Job [ct-job] has successfully been created.
To execute this job, use:
gcloud run jobs execute ct-job
real 0m2.632s
user 0m0.730s
sys 0m0.118s

--tasks=3:每次執行開 3 個 task--max-retries=1:每個 task 失敗最多重試 1 次(預設是 3 次,這裡改小方便觀察)--task-timeout=2m:每個 task 最多跑 2 分鐘(預設 10 分鐘),程式卡住時不會一直燒錢- 建立只花 2.6 秒,而且什麼都還沒跑。Job 只是一張工單,輸出也提醒你要用
execute才會執行;想建立完馬上跑,可以加--execute-now
步驟 5:執行 Job,等它跑完
time gcloud run jobs execute ct-job --region=asia-east1 --wait
Creating execution...
Provisioning resources...............................done
Starting execution.......................................................................done
Running execution.................................................................................(中間省略)......done
Done.
Execution [ct-job-95nmw] has successfully completed.
View details about this execution by running:
gcloud run jobs executions describe ct-job-95nmw
Or visit https://console.cloud.google.com/run/jobs/executions/details/asia-east1/ct-job-95nmw?project=600195576280
real 0m30.127s
user 0m0.901s
sys 0m0.124s

--wait讓指令等到整個 Execution 跑完才回來;不加的話指令馬上結束,Job 在背景自己跑- 每次執行都會產生一個新的 Execution,名字是 Job 名稱加 5 個亂數字(
ct-job-95nmw) - 程式本身只等 5 秒,整段卻花了 30.1 秒:多出來的是準備機器(Provisioning)、啟動容器、收尾的時間。所以很短的小工作,Jobs 的「開機成本」佔比很高
步驟 6:看執行紀錄
gcloud run jobs executions list --job=ct-job --region=asia-east1 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
✔
JOB: ct-job
EXECUTION: ct-job-95nmw
REGION: asia-east1
RUNNING: 0
COMPLETE: 3 / 3
CREATED: 2026-11-21 02:54:48 UTC
RUN BY: 你的帳號

COMPLETE: 3 / 3:3 個 task 都成功RUN BY:是誰按下執行的,後面用排程跑時會變成服務帳戶- 時間是 UTC(世界標準時間),台灣時間要加 8 小時,02:54 就是台灣上午 10:54
步驟 7:看每個 task 印了什麼
gcloud run jobs logs read ct-job --region=asia-east1 --limit=20 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
2026-11-21 02:55:02 task 0/3 attempt 0: 3 files ['report-01.csv', 'report-04.csv', 'report-07.csv']
2026-11-21 02:55:02 task 0: done
2026-11-21 02:55:11 task 1/3 attempt 0: 3 files ['report-02.csv', 'report-05.csv', 'report-08.csv']
2026-11-21 02:55:11 task 1: done
2026-11-21 02:55:11 task 2/3 attempt 0: 3 files ['report-03.csv', 'report-06.csv', 'report-09.csv']
2026-11-21 02:55:11 task 2: done

- 程式
print出來的字,Cloud Run 會自動收進 Cloud Logging(Google Cloud 的日誌服務),不用自己設定 - 9 個檔案平均分給 3 個 task,沒有重複、沒有漏掉,這就是
CLOUD_RUN_TASK_INDEX的用法:程式一樣,靠編號決定自己做哪一份 - task 0 和 task 1、2 差了 9 秒,3 個 task 沒有真的同時開始,原因寫在「實測時的意外」
步驟 8:故意讓 task 1 失敗一次,看自動重試
執行時可以臨時覆寫設定,只對這一次 Execution 有效。這次加上環境變數 FAIL_TASK=1,讓 task 1 第一次嘗試時故意失敗:
time gcloud run jobs execute ct-job --region=asia-east1 --wait --update-env-vars=FAIL_TASK=1
Creating execution...
Provisioning resources...................done
Starting execution...........................................................done
Running execution.................................................................................(中間省略)......done
Done.
Execution [ct-job-thw2p] has successfully completed.
View details about this execution by running:
gcloud run jobs executions describe ct-job-thw2p
Or visit https://console.cloud.google.com/run/jobs/executions/details/asia-east1/ct-job-thw2p?project=600195576280
real 0m38.975s
user 0m0.992s
sys 0m0.119s

有一個 task 失敗了,結果還是 successfully completed,而且比步驟 5 多花了約 9 秒。看這次 Execution 的詳細資料:
EXEC=$(gcloud run jobs executions list --job=ct-job --region=asia-east1 --limit=1 --format='value(name)'); gcloud run jobs executions describe $EXEC --region=asia-east1 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
✔ Execution ct-job-thw2p in region asia-east1
3 tasks completed successfully
Elapsed time: 34 seconds
Log URI: https://console.cloud.google.com/logs/viewer?project=dong-dong-gcp-3&advancedFilter=(中間省略)
Tasks: 3
Parallelism: 3
Container None
Image: asia-east1-docker.pkg.dev/dong-dong-gcp-3/ct-demo/ct-job@sha256:c7f3f2b877833380cc24682d5a5670391096e7aed729e1f362d9f6c16f628a73
Memory: 512Mi
CPU: 1000m
Env vars:
FAIL_TASK 1
Task Timeout: 2m
Max Retries: 1
Service account: 600195576280-compute@developer.gserviceaccount.com
✔ Execution completed successfully in 31.92s.

Env vars: FAIL_TASK 1:覆寫的環境變數只出現在這次 Execution,Job 本身的設定沒變Parallelism: 3:沒設--parallelism時,預設盡量讓全部 task 一起跑Memory: 512Mi、CPU: 1000m:Jobs 預設 512 MiB 記憶體、1 vCPU- 這裡看不出有重試,要看每個 task 的狀態:
gcloud run jobs executions tasks list --execution=$EXEC --region=asia-east1 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
✔
INDEX: 0
STATE: Succeeded
TASK: ct-job-thw2p-task0
STARTED: 2026-11-21 02:55:46 UTC
COMPLETED: 2026-11-21 02:55:55 UTC
RETRIES: 0
✔
INDEX: 1
STATE: Succeeded
TASK: ct-job-thw2p-task1
STARTED: 2026-11-21 02:55:56 UTC
COMPLETED: 2026-11-21 02:56:15 UTC
RETRIES: 1
✔
INDEX: 2
STATE: Succeeded
TASK: ct-job-thw2p-task2
STARTED: 2026-11-21 02:55:56 UTC
COMPLETED: 2026-11-21 02:56:03 UTC
RETRIES: 0

task 1 的 RETRIES: 1,從開始到結束花了 19 秒,其他兩個各 7~9 秒。再看日誌,加上 task 編號和第幾次嘗試:
echo 'TIME TASK ATTEMPT LOG'; gcloud logging read "resource.type=cloud_run_job AND labels.\"run.googleapis.com/execution_name\"=$EXEC AND textPayload:*" --order=asc --limit=50 --format='value(timestamp.date("%H:%M:%S"),labels."run.googleapis.com/task_index",labels."run.googleapis.com/task_attempt",textPayload)'
TIME TASK ATTEMPT LOG
02:55:51 0 0 task 0/3 attempt 0: 3 files ['report-01.csv', 'report-04.csv', 'report-07.csv']
02:55:51 0 0 task 0: done
02:55:51 0 0 Container called exit(0).
02:55:56 1 0 task 1/3 attempt 0: 3 files ['report-02.csv', 'report-05.csv', 'report-08.csv']
02:55:56 1 0 task 1: simulated error, exit 1
02:55:57 1 0 Container called exit(1).
02:56:02 2 0 task 2/3 attempt 0: 3 files ['report-03.csv', 'report-06.csv', 'report-09.csv']
02:56:02 2 0 task 2: done
02:56:02 2 0 Container called exit(0).
02:56:11 1 1 task 1/3 attempt 1: 3 files ['report-02.csv', 'report-05.csv', 'report-08.csv']
02:56:11 1 1 task 1: done
02:56:11 1 1 Container called exit(0).

- task 1 第一次(attempt 0)在 02:55:57 以
exit(1)失敗 - 約 14 秒後 02:56:11,Cloud Run 自動重試(attempt 1),這次
FAIL_TASK的條件不成立,正常跑完 - 重試時
CLOUD_RUN_TASK_INDEX還是 1,處理的還是同樣 3 個檔案。所以程式要寫成「重跑一次也不會出錯」,例如同一個檔案處理兩次結果一樣,這叫冪等(Idempotent)
步驟 9:用 Cloud Scheduler 排程
Cloud Scheduler 是 Google Cloud 的排程服務:照你設定的時間,自動去呼叫一個網址或觸發一個工作。 比喻是鬧鐘,時間到就叫人起床。Jobs 沒有網址,排程的做法是讓 Cloud Scheduler 呼叫 Cloud Run 的 API「執行這個 Job」:
PROJECT=$(gcloud config get-value project 2>/dev/null); PNUM=$(gcloud projects describe $PROJECT --format='value(projectNumber)'); gcloud scheduler jobs create http ct-job-weekly --location=asia-east1 --schedule='0 9 * * 1' --time-zone='Asia/Taipei' --uri="https://run.googleapis.com/v2/projects/$PROJECT/locations/asia-east1/jobs/ct-job:run" --http-method=POST --oauth-service-account-email=$PNUM-compute@developer.gserviceaccount.com --format='yaml(name,schedule,timeZone,state)' 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
name: projects/dong-dong-gcp-3/locations/asia-east1/jobs/ct-job-weekly
schedule: 0 9 * * 1
state: ENABLED
timeZone: Asia/Taipei

--schedule='0 9 * * 1'是 cron 格式,五格依序是:分、時、日、月、星期幾。這行的意思是「每週一 9 點 0 分」。每天凌晨 2 點就是0 2 * * *--time-zone='Asia/Taipei':照台灣時間算,不加的話預設是 UTC--uri:Cloud Run 執行 Job 的 API 網址,結尾是jobs/ct-job:run--oauth-service-account-email:用哪個服務帳戶(給程式用的帳號)的身分去執行。這裡照官方文件用專案的 Compute Engine 預設服務帳戶,這個專案的預設帳戶有編輯者權限,所以不用另外授權。正式環境建議另外建一個只有roles/run.invoker(執行權限)的服務帳戶,權限越小越安全,可以參考Service Account 開發小技巧
不用等到週一,可以先手動觸發一次,看它有沒有真的叫起 Job:
gcloud scheduler jobs run ct-job-weekly --location=asia-east1 && sleep 45 && gcloud run jobs executions list --job=ct-job --region=asia-east1 --limit=1 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
✔
JOB: ct-job
EXECUTION: ct-job-rg82t
REGION: asia-east1
RUNNING: 0
COMPLETE: 3 / 3
CREATED: 2026-11-21 02:58:29 UTC
RUN BY: 600195576280-compute@developer.gserviceaccount.com

- 多了一筆新的 Execution
ct-job-rg82t,3 個 task 都完成 RUN BY從「你的帳號」變成服務帳戶,代表這次是排程觸發的sleep 45是等 45 秒讓 Job 跑完再查
在 Console 也可以設:Cloud Run 的 Jobs 頁面點進 Job,選「觸發條件」分頁,按「Add Scheduler Trigger」(新增排程器觸發條件),填的欄位跟上面的指令一樣(2026 年 11 月查官方排程說明)。
步驟 10:寫一個 Cloud Run function
換 functions。這次只寫一段函式和一行套件清單,沒有 Dockerfile:
mkdir -p ~/ct-jobs/func && cd ~/ct-jobs/func
cat > main.py <<'EOF'
import functions_framework
@functions_framework.http
def hello_get(request):
name = request.args.get("name", "Cloud Run")
return f"Hello {name}, from a Cloud Run function!\n"
EOF
cat > requirements.txt <<'EOF'
functions-framework==3.9.2
EOF
ls
main.py requirements.txt

@functions_framework.http:告訴 Functions Framework「這個函式要接 HTTP 請求」。Functions Framework 是 Google 開源的小工具,負責開網頁伺服器、把請求交給你的函式,你就不用自己寫 Flaskrequest.args.get("name", ...):讀網址後面的?name=...,沒給就用Cloud Runrequirements.txt:Python 的套件清單,版本照官方範例寫(2026 年 11 月查官方快速入門)
步驟 11:部署 function
time gcloud run deploy ct-func --source=. --function=hello_get --base-image=python314 --image=$REPO/ct-func --region=asia-east1 --allow-unauthenticated
Building using Buildpacks and deploying container to Cloud Run service [ct-func] in project [dong-dong-gcp-3] region [asia-east1]
Building and deploying new service...
Validating configuration........done
Uploading sources........done
Building Container.................................................................................(中間省略)......done
Setting IAM Policy............done
Creating Revision.................................................................done
Routing traffic.....done
Done.
Service [ct-func] revision [ct-func-00001-p7m] has been deployed and is serving 100 percent of traffic.
Service URL: https://ct-func-600195576280.asia-east1.run.app
real 0m47.533s
user 0m1.241s
sys 0m0.162s

| 參數 | 意思 |
|---|---|
--source=. | 上傳目前資料夾的程式碼,交給 Cloud Build 打包 |
--function=hello_get | 要執行哪個函式,名字要跟 main.py 裡的一樣 |
--base-image=python314 | 用 Google 準備好的 Python 3.14 執行環境當底 |
--image=$REPO/ct-func | 打包好的映像檔推到自己的 ct-demo 存放區,名字要跟服務同名 |
--allow-unauthenticated | 任何人都能連,練習完要刪 |
- 輸出第一行就寫
Building using Buildpacks ... to Cloud Run service。Buildpacks 是自動看你用什麼程式語言、幫你產生映像檔的工具,所以不用寫 Dockerfile - 不加
--image的話,映像檔會推到 Cloud Run 自動建立的cloud-run-source-deploy存放區(第 20 篇實測過) - 花 47.5 秒,大部分時間在 Cloud Build 打包;之後改程式重新部署,也要再打包一次
步驟 12:連看看
FURL=$(gcloud run services describe ct-func --region=asia-east1 --format='value(status.url)'); curl -s "$FURL?name=Taipei"; curl -s -o /dev/null -w "code=%{http_code} total=%{time_total}s\n" "$FURL"
Hello Taipei, from a Cloud Run function!
code=200 total=0.038028s

code=200 是 HTTP 狀態碼「成功」,第二次請求只花 0.038 秒,跟第 22 篇量到的服務熱請求一樣快。
步驟 13:function 其實就是一個服務
把專案裡 ct- 開頭的服務和 Jobs 都列出來:
gcloud run services list --filter='metadata.name~^ct-' 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'; gcloud run jobs list --filter='metadata.name~^ct-' 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
✔
SERVICE: ct-func
REGION: asia-east1
URL: https://ct-func-600195576280.asia-east1.run.app
LAST DEPLOYED BY: 你的帳號
LAST DEPLOYED AT: 2026-11-21T03:00:15.577296Z
✔
JOB: ct-job
REGION: asia-east1
LAST RUN AT: 2026-11-21 02:58:29 UTC
CREATED: 2026-11-21 02:54:37 UTC
CREATED BY: 你的帳號

ct-func出現在服務清單裡,有URLct-job在 Jobs 清單裡,根本沒有URL這一欄,只有上次什麼時候跑
再看服務的設定裡記了什麼,順便用舊的 gcloud functions 指令找找看:
gcloud run services describe ct-func --region=asia-east1 --format=export | grep -E 'function|base-image'; gcloud functions list --regions=asia-east1 2>&1 | sed -E 's/[a-z0-9.]+@gmail\.com/你的帳號/g'
run.googleapis.com/build-base-image: asia-east1-docker.pkg.dev/serverless-runtimes/google-24/runtimes/python314
run.googleapis.com/build-function-target: hello_get
run.googleapis.com/base-images: '{"":"asia-east1-docker.pkg.dev/serverless-runtimes/google-24/runtimes/python314"}'
runtimeClassName: run.googleapis.com/linux-base-image-update
Listed 0 items.

build-function-target: hello_get:這個服務記住了「要執行哪個函式」,它就是一個帶著函式資訊的 Cloud Run 服務linux-base-image-update:開了自動更新基礎映像檔,作業系統和 Python 執行環境的安全修補由 Google 自動套用,不用重新建置、不會產生新的修訂版本(2026 年 11 月查官方說明)gcloud functions list找不到它(Listed 0 items.):用gcloud run deploy --function建的函式,只能用 Cloud Run 的工具管理
步驟 14:映像檔和原始碼放在哪
gcloud artifacts docker images list $REPO --include-tags --format='table(package.basename():label=IMAGE,tags:label=TAGS,createTime.date("%H:%M"):label=TIME)'; gcloud storage ls gs://run-sources-$PROJECT-asia-east1/services/ct-func/
Listing items under project dong-dong-gcp-3, location asia-east1, repository ct-demo.
IMAGE: ct-func
TAGS:
TIME: 03:00
IMAGE: ct-func
TAGS:
TIME: 03:00
IMAGE: ct-func
TAGS: latest
TIME: 02:59
(中間省略:ct-job 的 3 筆)
gs://run-sources-dong-dong-gcp-3-asia-east1/services/ct-func/1795229970.463432-f5f4d067368144edad7de1e5af05ef14.zip

- function 打包好的映像檔在自己的
ct-demo存放區,有 3 筆,只有一筆標latest - 上傳的原始碼壓縮檔放在 Cloud Storage 的
run-sources-專案ID-asia-east1bucket 裡。bucket 是 Cloud Storage 裡裝檔案的容器,這個 bucket 是 Cloud Run 自動建的,同專案的原始碼部署都放這裡,只刪自己那個資料夾,不要刪整個 bucket
實測時的意外
1. 平行數 3,3 個 task 卻沒有同時開始
步驟 7 的 task 0 在 02:55:02 跑完,task 1、2 晚了 9 秒;步驟 8 的三個 task 也是 02:55:51、02:55:56、02:56:02 陸續印出第一行。Parallelism: 3 的意思是「最多 3 個一起跑」,不保證同時開始。官方文件也寫,實際同時跑的 task 數可能比設定的少(2026 年 11 月查平行數說明)。程式不要假設「所有 task 一定同時開始、同時結束」。
2. executions describe 看不出有重試
步驟 8 有一個 task 失敗又重試,executions describe 只寫 3 tasks completed successfully,看起來跟沒出事一樣。要用 gcloud run jobs executions tasks list 看每個 task 的 RETRIES 欄位,才知道有 task 重試過。實務上 Job 「成功」不代表每個 task 都一次就過,常常重試的 task 要去查原因。
3. 日誌查詢加了 --limit 卻少了幾行
第一次用 gcloud logging read ... --limit=30 查重試那次的日誌,只看到 attempt 0 的行,attempt 1 的「重試成功」不見了。原因是 Cloud Run 還會寫一些沒有文字內容的系統日誌,佔掉了筆數上限。查詢條件加上 textPayload:*(只要有文字內容的),筆數放大到 50,重試那幾行才出現。
4. 用 Cloud Run 建的 function,gcloud functions list 找不到
網路上的 Cloud Functions 教學都用 gcloud functions list 看函式,但步驟 13 用 gcloud run deploy --function 建的 ct-func 不會出現在裡面。官方比較頁寫,用 Cloud Run Admin API 建的函式只能用 Cloud Run 的工具管理;反過來,用 gcloud functions deploy 建的,兩邊都看得到。
5. 一個 task 只跑 5 秒,整個 Execution 要 30 秒
步驟 5 的程式只等 5 秒,execute --wait 卻花了 30.1 秒。Jobs 每次執行都要準備機器、啟動容器,加上每台最少算 1 分鐘的計費,很短、很頻繁的小工作(例如每分鐘要回應一次)比較適合做成服務或 function,不適合 Jobs。
用完記得刪
先刪排程,再刪 Job:
gcloud scheduler jobs delete ct-job-weekly --location=asia-east1 --quiet
Deleted job [ct-job-weekly].

gcloud run jobs delete ct-job --region=asia-east1 --quiet
Deleting [ct-job]...
..done.
Deleted job [ct-job].

再刪 function(它是服務,所以用 services delete):
gcloud run services delete ct-func --region=asia-east1 --quiet
Deleting [ct-func]...
..done.
Deleted service [ct-func].

最後刪原始碼壓縮檔、存放區、Cloud Shell 裡的映像檔和資料夾:
gcloud storage rm -r gs://run-sources-$PROJECT-asia-east1/services/ct-func/; gcloud artifacts repositories delete ct-demo --location=asia-east1 --quiet; docker rmi $REPO/ct-job:v1 >/dev/null; cd ~ && rm -rf ~/ct-jobs; echo cleaned
Removing objects:
Removing gs://run-sources-dong-dong-gcp-3-asia-east1/services/ct-func/1795229970.463432-f5f4d067368144edad7de1e5af05ef14.zip#1795229970565974...
Delete request issued for: [ct-demo]
Waiting for operation [projects/dong-dong-gcp-3/locations/asia-east1/operations/ec10e565-1c85-475e-a587-52c119989adb] to complete...
.done.
Deleted repository [ct-demo].
cleaned

不刪會怎麼計費:
| 資源 | 不刪的話 |
|---|---|
| Cloud Scheduler 排程 | 每個每 31 天 0.10 美元(每個帳單帳戶前 3 個免費),而且每週一會自動執行 Job |
| Cloud Run Job | 不執行就不收錢;但排程還在的話會照時間跑 |
| function(服務) | 沒人連不收運算費;開了 --allow-unauthenticated,被人一直打會計費 |
| 存放區的映像檔 | Artifact Registry 每月 0.5 GiB 免費,超過照容量計費 |
最容易忘的是排程:Job 還在而排程沒刪,就會一直照時間跑、一直計費;Job 刪了但排程還在,排程會一直去叫一個不存在的 Job,還是佔一個排程的費用。
面試/證照會怎麼問
面試常見題
- 「Cloud Run 的服務和 Jobs 差在哪?」:服務有網址、等請求、不會自己結束;Jobs 沒有網址,執行一次就跑到結束,可以拆多個 task、失敗自動重試,每個 task 最多 168 小時
- 「每天凌晨要處理一批檔案,用什麼?」:Cloud Run Jobs 加 Cloud Scheduler 排程,用
CLOUD_RUN_TASK_INDEX把檔案分給多個 task - 「Cloud Functions 和 Cloud Run 有什麼關係?」:Cloud Functions 第二代已改名 Cloud Run functions,部署完就是一個 Cloud Run 服務,可以用 Cloud Run 的流量分割、並行數這些功能
- 「Job 的 task 會重試,程式要注意什麼?」:要冪等,同一份資料處理兩次結果要一樣,例如寫檔案用覆蓋、寫資料庫先檢查有沒有做過
Google Cloud 證照(ACE、PCA)
Associate Cloud Engineer:報名費 125 美元、2 小時、50~60 題單選和複選、效期 3 年(2026 年 11 月查官方考試頁),是情境選擇題,不是上機考。Professional Cloud Architect 的準備方式可以看雲端架構師證照怎麼準備。
看到這些字,就想到這個
| 題目關鍵字 | 想到 |
|---|---|
| 「批次處理」「跑完就結束」「定時執行」「不需要回應請求」 | Cloud Run Jobs(+Cloud Scheduler) |
| 「執行時間超過 60 分鐘」「最長數小時」 | Cloud Run Jobs(task 最多 168 小時) |
| 「網站」「API」「需要固定網址」 | Cloud Run 服務 |
| 「檔案上傳到 Cloud Storage 就處理」「Pub/Sub 訊息觸發」「只寫一段程式碼」 | Cloud Run functions(Eventarc 觸發) |
| 「持續從佇列拉訊息」「不需要網址」 | Cloud Run worker pools |
| 「每天定時」「cron」 | Cloud Scheduler |
常見問答
Cloud Run Jobs 是什麼?
Cloud Run Jobs 是 Cloud Run 執行「做完就結束」程式的方式:沒有網址、不聽請求,執行一次就跑到結束。一個 Job 可以拆成最多 10,000 個 task 一起跑,每個 task 靠 CLOUD_RUN_TASK_INDEX 環境變數知道自己處理哪一份,失敗預設自動重試 3 次,每個 task 最多跑 168 小時(2026 年 11 月查官方文件)。
Cloud Run Jobs 和 Cloud Run 服務差在哪?
服務有固定網址,等請求進來才處理,處理完會繼續等,一個請求最多 60 分鐘;Jobs 沒有網址,手動或排程執行,程式跑完就結束,一個 task 最多 168 小時。計費也不同:服務預設以請求計費,Jobs 一律以執行個體計費、每台最少算 1 分鐘。網站、API 選服務,批次、排程工作選 Jobs。
Cloud Run functions 和 Cloud Functions 是同一個嗎?
是同一條產品線改名。Cloud Functions(2nd gen)現在叫 Cloud Run functions,部署完就是一個 Cloud Run 服務;Cloud Functions(1st gen)現在叫 Cloud Run functions(1st gen)。官方建議用 gcloud run deploy --function 部署,這樣建的函式不會出現在 gcloud functions list,只能用 Cloud Run 的工具管理。
Cloud Run Jobs 最多可以跑多久?
每個 task 預設最多 10 分鐘,可以用 --task-timeout 調到最多 168 小時(7 天),用 GPU 的 task 最多 12 小時(2026 年 11 月查官方文件)。整個 Execution 沒有時間上限,所有 task 跑完就結束。官方建議所有 Job 都開重試,跑越久越可能遇到下游服務出錯、記憶體不足這類問題;用 GPU 的 task 遇到基礎設施維護還會直接被中斷。
Cloud Run Jobs 怎麼排程?
用 Cloud Scheduler 呼叫 Cloud Run 的 API https://run.googleapis.com/v2/projects/專案ID/locations/區域/jobs/Job名稱:run,排程用 cron 格式(例如每天凌晨 2 點是 0 2 * * *),加 --time-zone='Asia/Taipei' 照台灣時間算。Console 也可以在 Job 的「觸發條件」分頁直接新增。Cloud Scheduler 每個排程每 31 天 0.10 美元,每個帳單帳戶前 3 個免費。
Cloud Run Jobs 怎麼收費?
一律以執行個體計費,每個 task 從開機到結束都算,每台最少算 1 分鐘,不收請求費。台灣 asia-east1 每 vCPU 秒 0.000018 美元、每 GiB 秒 0.000002 美元,每月免費 24 萬 vCPU 秒、45 萬 GiB 秒(2026 年 11 月查官方定價頁)。每天跑一次、10 個 task 各 5 分鐘、1 vCPU、512 MiB,整個月在免費額度內。
worker pools 是什麼?跟 Jobs 差在哪?
worker pools 是一直開著、在背景從訊息佇列(例如 Pub/Sub、Kafka)拉工作出來處理的 Cloud Run 資源,沒有網址、不會自動擴展,台數自己設。Jobs 是做完就結束,worker pools 是不會結束。台灣 asia-east1 單價每 vCPU 秒 0.000011244 美元,比服務的以執行個體計費(0.000018 美元)便宜約 38%。
重點整理
- Cloud Run Jobs 是跑完就結束的工作:沒有網址,手動或 Cloud Scheduler 排程執行,Job(工單)執行一次產生一個 Execution,裡面最多 10,000 個 Task
- 用
CLOUD_RUN_TASK_INDEX分工:同一個程式,每個 task 靠編號挑自己那一份;失敗會自動重試(預設 3 次),程式要寫成重跑也不出錯 - Cloud Run functions 就是 Cloud Run 服務:只寫函式不用 Dockerfile,
gcloud run deploy --function用 Buildpacks 打包,以前叫 Cloud Functions - 怎麼選:做完就結束選 Jobs,要網址選服務,只是一段小程式選 functions,一直在背景拉訊息選 worker pools
- 收費不同:Jobs 一律以執行個體計費、每台最少 1 分鐘;服務和 functions 預設以請求計費;排程另收每個 31 天 0.10 美元(前 3 個免費)
延伸閱讀
本系列
- 第 1 篇:Docker 入門教學:不用安裝,用 Cloud Shell 跑出第一個容器
- 第 4 篇:Dockerfile 怎麼寫?從零打包你的第一個網頁映像檔
- 第 19 篇:Artifact Registry 是什麼?把 Docker 映像檔推上 GCP 教學
- 第 20 篇:Cloud Run 是什麼?Cloud Run 教學:部署容器、版本與流量分割
- 第 21 篇:Cloud Build 是什麼?用 cloudbuild.yaml 自動建映像檔、部署到 Cloud Run
- 上一篇:第 22 篇:Cloud Run 收費怎麼算?Cloud Run pricing、冷啟動、最小執行個體一次看懂
- 下一篇:第 24 篇:GKE 是什麼?Google Kubernetes Engine 教學:Autopilot 和 Standard 怎麼選
Cloud Run、無伺服器相關
- 上傳程式碼就能跑的微服務:Cloud Run Functions 簡介與基本操作教學
- Cloud Pub/Sub 教學:比 RabbitMQ 好用,無限擴充的訊息佇列服務
- 使用 GCP Service Account 開發程式的小技巧和注意事項
- GCP 帳單爆炸防護
站上相關文章
Cloud Run 的三種跑法比完了,下一篇進到 GKE,看什麼時候該從 Cloud Run 換成 Kubernetes。可以看看東東的 GCP 課程,或加 LINE 聊聊你現在的狀況,一起找出最適合你的學習順序。