Cloud Run Jobs 是什麼?服務、Jobs、functions 差在哪、怎麼選

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 月查官方文件的數字,以後可能調整。

Cloud Run 服務、Jobs、functions 比較:服務像便利商店開著門等客人,有網址、一個請求最多 60 分鐘;Jobs 像搬家公司接案做完就收工,沒有網址、可拆成多個 task、每個 task 最多 168 小時;functions 像自動販賣機只做一件事,只寫函式不用 Dockerfile,Cloud Run 幫你包成服務

為什麼你需要知道

  • 選錯會多寫很多程式:把每天跑一次的批次工作做成服務,要自己寫一個網址讓排程去叫它、還要擔心請求 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這次總共幾個 task3
CLOUD_RUN_TASK_ATTEMPT這是第幾次嘗試,從 0 開始,重試會加 10、1
CLOUD_RUN_EXECUTION這次 Execution 的名字ct-job-thw2p
Cloud Run Jobs 的 Job、Execution、Task 關係:Job ct-job 設定 3 個 tasks、重試 1 次,執行一次產生 Execution ct-job-thw2p,最多 3 個 Task 一起跑,task 1 第一次 exit(1) 失敗後自動重試成功

Jobs 的重要設定與上限

設定gcloud 參數預設上限
task 數量--tasks110,000
同時跑幾個--parallelism盡量全部一起跑看區域和規格
每個 task 失敗重試幾次--max-retries310
每個 task 最多跑多久--task-timeout10 分鐘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 --functiongcloud functions deploy --no-gen2
也能用gcloud functions deploy(Cloud Functions v2 API)
網址run.appcloudfunctions.net
一個 HTTP 請求最多60 分鐘9 分鐘
一台同時處理幾個請求最多 1,0001
計費照 Cloud Run 定價第一代自己的定價

(2026 年 11 月查官方比較頁)

官方現在建議用 gcloud run deploy --function 建函式。要注意:用這個方式建的函式,只能用 Cloud Run 的工具管理,不能再用 gcloud functions 指令改。站上Cloud Run Functions 簡介有 Console 介面的操作,這篇用指令做。


一張表比較:服務、Jobs、functions

服務Jobsfunctions
怎麼開始跑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 是別的系統在某件事發生時,主動打你的網址通知你。

Cloud Run Jobs、服務、functions 怎麼選的判斷流程:做完就結束選 Cloud Run Jobs,要有網址回應 HTTP 請求選 Cloud Run 服務,只是一段函式不想寫 Dockerfile 選 Cloud Run functions,一直在背景拉訊息不需要網址選 worker pools

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
gcloud config get-value project 顯示專案 dong-dong-gcp-3,啟用 Cloud Run、Artifact Registry、Cloud Build、Cloud Scheduler 四個 API 後印出 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
在 Cloud Shell 用 cat 和 EOF 建立 Cloud Run Jobs 範例程式 job.py 和 Dockerfile,程式讀 CLOUD_RUN_TASK_INDEX、CLOUD_RUN_TASK_COUNT、CLOUD_RUN_TASK_ATTEMPT 三個環境變數
  • 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
建立 Artifact Registry 存放區 ct-demo,docker build 和 docker push 把 Cloud Run Jobs 用的映像檔 ct-job:v1 推上 asia-east1-docker.pkg.dev

存放區、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
gcloud run jobs create 建立 Cloud Run Job ct-job,設定 3 個 tasks、最多重試 1 次、每個 task 逾時 2 分鐘,花 2.632 秒
  • --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
gcloud run jobs execute ct-job --wait 執行 Cloud Run Job,產生 Execution ct-job-95nmw 並成功完成,整段花 30.127 秒
  • --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: 你的帳號
gcloud run jobs executions list 列出 Cloud Run Job ct-job 的執行紀錄,Execution ct-job-95nmw 完成 3 / 3 個 task
  • 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
gcloud run jobs logs read 讀 Cloud Run Job 日誌,三個 task 依 CLOUD_RUN_TASK_INDEX 各自處理 3 個報表檔,task 0 在 02:55:02 跑完,task 1 和 2 在 02:55:11 跑完
  • 程式 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
gcloud run jobs execute 加 --update-env-vars=FAIL_TASK=1 讓 task 1 故意失敗,Execution ct-job-thw2p 仍然成功完成,花 38.975 秒

有一個 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.
gcloud run jobs executions describe 顯示 Cloud Run Job 執行 ct-job-thw2p 3 個 task 全部成功,Parallelism 3、Memory 512Mi、CPU 1000m、環境變數 FAIL_TASK 1、Max Retries 1
  • 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
gcloud run jobs executions tasks list 列出三個 task,task 1 的 RETRIES 是 1,從 02:55:56 跑到 02:56:15,比其他 task 多花約 10 秒

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).
gcloud logging read 讀 Cloud Run Job 日誌,task 1 第一次嘗試 attempt 0 結束代碼 exit(1) 失敗,約 14 秒後 attempt 1 自動重試並 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
gcloud scheduler jobs create http 建立 Cloud Scheduler 排程 ct-job-weekly,每週一台北時間 9 點呼叫 Cloud Run Jobs API 執行 ct-job,狀態 ENABLED
  • --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
gcloud scheduler jobs run 手動觸發排程,45 秒後 Cloud Run Job 多了一筆執行 ct-job-rg82t,完成 3 / 3,RUN BY 是 Compute Engine 預設服務帳戶
  • 多了一筆新的 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
建立 Cloud Run functions 範例 main.py 和 requirements.txt,main.py 用 functions_framework.http 定義 hello_get 函式,沒有 Dockerfile
  • @functions_framework.http:告訴 Functions Framework「這個函式要接 HTTP 請求」。Functions Framework 是 Google 開源的小工具,負責開網頁伺服器、把請求交給你的函式,你就不用自己寫 Flask
  • request.args.get("name", ...):讀網址後面的 ?name=...,沒給就用 Cloud Run
  • requirements.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
gcloud run deploy ct-func --function=hello_get --base-image=python314 用 Buildpacks 建置並部署成 Cloud Run 服務 ct-func,花 47.533 秒,印出服務網址
參數意思
--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
curl 連 Cloud Run function 網址帶 name=Taipei,回傳 Hello Taipei, from a Cloud Run function!,狀態碼 200、0.038 秒

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: 你的帳號
gcloud run services list 列出 ct-func 是 Cloud Run 服務、有 URL;gcloud run jobs list 列出 ct-job 是 Cloud Run Job、沒有 URL 欄位
  • ct-func 出現在服務清單裡,有 URL
  • ct-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.
gcloud run services describe 顯示 ct-func 服務記錄 build-function-target hello_get 和 Python 3.14 基礎映像檔;gcloud functions list 列出 0 個,用 Cloud Run 建的函式不會出現在舊指令
  • 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
Artifact Registry 存放區 ct-demo 裡有 ct-func 和 ct-job 映像檔,function 上傳的原始碼壓縮檔放在 Cloud Storage 的 run-sources bucket
  • function 打包好的映像檔在自己的 ct-demo 存放區,有 3 筆,只有一筆標 latest
  • 上傳的原始碼壓縮檔放在 Cloud Storage 的 run-sources-專案ID-asia-east1 bucket 裡。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 scheduler jobs delete 刪除 Cloud Scheduler 排程 ct-job-weekly
gcloud run jobs delete ct-job --region=asia-east1 --quiet
Deleting [ct-job]...
..done.
Deleted job [ct-job].
gcloud run jobs delete 刪除 Cloud Run Job ct-job,印出 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].
gcloud run services delete 刪除 Cloud Run function ct-func,因為 function 就是一個 Cloud Run 服務

最後刪原始碼壓縮檔、存放區、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
刪除 run-sources bucket 裡 ct-func 的原始碼壓縮檔、刪除 Artifact Registry 存放區 ct-demo 和 Cloud Shell 的 ct-jobs 資料夾,印出 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 個免費)

延伸閱讀

本系列

Cloud Run、無伺服器相關

站上相關文章


Cloud Run 的三種跑法比完了,下一篇進到 GKE,看什麼時候該從 Cloud Run 換成 Kubernetes。可以看看東東的 GCP 課程,或加 LINE 聊聊你現在的狀況,一起找出最適合你的學習順序。

返回頂端