結論
Cloud Run は、コンテナ(またはソースコード)を渡すだけで、Google Cloud がサーバーの用意・増減・TLS を引き受けて動かすサービスです。リクエストが無いときはインスタンスが 0 まで減り、既定の課金ではリクエストを処理している間だけ料金がかかります。
この記事でわかること
- サービス・ジョブ・ワーカープール・Cloud Run functions の違い
- PORT で待ち受けるコンテナを手元で動かした出力と、デプロイの流れ
- 料金と無料枠、月の件数別に Python で試算した金額
この記事で実際に動かしたものは、Cloud Run のコンテナの決まりに沿って書いた Python の Web サーバー(127.0.0.1 で起動)、ジョブのタスク分割のスクリプト、料金の試算のスクリプト、gcloud run deploy --help の表示です。
flowchart TD
S[ソースコード] -->|gcloud run deploy --source| B[Cloud Build で<br>イメージを作る]
I[コンテナイメージ] --> AR[Artifact Registry]
B --> AR
AR -->|gcloud run deploy --image| R[リビジョンを作る]
R --> U[run.app の URL で公開]
U -->|リクエストが来る| N[インスタンスが増える]
N -->|来なくなる| Z[0 まで減る]
よく調べられることの答えを先にまとめます。
| 知りたいこと | 答え | 詳しい節 |
|---|---|---|
| Cloud Run とは | コード・関数・コンテナを動かすフルマネージドの実行基盤 | Cloud Runとは |
| サービスとジョブの違い | サービスは HTTP に応える。ジョブは最後まで動いて終わる | サービス・ジョブ・ワーカープールの違い |
| コンテナの決まり | PORT(既定 8080)の 0.0.0.0 で待ち受け、起動後 4 分以内に応答できる | コンテナの決まり |
| Cloud Run の使い方 | gcloud run deploy に --image か --source を付ける |
デプロイの流れ |
| 料金・無料枠 | 処理中の CPU $0.000024/vCPU 秒など。毎月 180,000 vCPU 秒・200 万リクエストが無料 | 料金と無料枠 |
| コールドスタート対策 | 最小インスタンス数・起動時の CPU ブースト・依存を減らす | 同時実行・最小インスタンス |
| Lambda・ECS との違い | タイムアウト上限(60 分と 15 分)や、組み立てる部品の数が違う | Lambda・ECS との違い |
| Cloud Functions との関係 | Cloud Functions(第 2 世代)は Cloud Run functions に名前が変わった | サービス・ジョブ・ワーカープールの違い |
確認環境:Ubuntu 24.04.5 LTS の上で、Python 3.13.18 の標準ライブラリ(http.server)で Cloud Run のコンテナの決まりに沿った Web サーバーを書き、環境変数 PORT を渡して 127.0.0.1 で起動し、curl 8.5.0 で応答・並行処理・SIGTERM での停止を確かめました。ジョブのタスク分割は、CLOUD_RUN_TASK_INDEX などを手で渡して再現しています。Docker は CLI 29.9.2 が入っていましたが、デーモンが動いておらず(起動もしていません)、コンテナイメージのビルドとコンテナとしての実行はしていません。Google Cloud SDK 570.0.0 はログインせず、外部へ出ない設定で gcloud run deploy --help などのヘルプだけを表示しました。Cloud Run へのデプロイ・ログイン・課金は一切していません。サービスの仕様・上限値・料金は Google Cloud の公式ドキュメントと料金のページ、Lambda と ECS の値は AWS の公式ドキュメントで確かめました(確認日 2026年11月18日)。
本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。
(記載例)出典:株式会社RJC「Cloud Runとは|使い方・料金の試算・コンテナをデプロイする流れ」
Cloud Runとは(サーバーレスでコンテナを動かすサービス)
この節では、Cloud Run がどんなサービスで、何を任せられるのかが分かります。
Cloud Run は、Google Cloud の公式ドキュメントで「スケーラビリティに優れた Google のインフラストラクチャ上でコード、関数、コンテナを実行できるフルマネージド アプリケーション プラットフォーム」と説明されているサービスです。 クラスタの作成やサーバーの管理は要らず、作ったコンテナイメージを渡すと、URL が付いて動き始めます。
コンテナイメージを作れる言語なら何でも動かせます。Go・Node.js・Python・Java・.NET・Ruby などは、ソースコードから直接デプロイする方法もあり、その場合は Google の Buildpack がコンテナ化を代わりに行います。
1サーバーを持たない
OS の更新・台数の決定・TLS の証明書は Cloud Run が受け持つ。渡すのはコンテナイメージかソースコードだけ。
20 まで減る
リクエストが無くなるとインスタンスは 0 になる。既定の課金では、そのあいだ料金はかからない。
3デプロイごとにリビジョン
デプロイや設定の変更のたびに、変更できないリビジョンが作られる。トラフィックを割合で分けたり、前のリビジョンへ戻したりできる。
サービスには *.run.app の固有のサブドメインが割り当てられ、カスタムドメインも設定できます。WebSocket・HTTP/2・gRPC にも対応しています。コンテナのログは Cloud Logging に自動で取り込まれます。
Google Cloud 全体の中での位置づけは、関連記事「GCPとは|Google Cloudの主要サービス・料金・無料枠・始め方」で扱っています。この記事では Cloud Run の仕組みと使い方に絞ります。ファイルの置き場所は「Cloud Storageの使い方|バケット作成・アップロード・料金とgcloud」で扱います。
Cloud Runのサービス・ジョブ・ワーカープールの違い(Cloud Run functionsも)
この節では、Cloud Run でコードを動かす 3 つの形と、Cloud Run functions がどれに当たるのかが分かります。
Cloud Run には、サービス・ジョブ・ワーカープールの 3 つのリソースがあり、どれも同じ実行環境のコンテナで動きます。 違いは「何をきっかけに動き、いつ止まるか」です。
| リソース | 動くきっかけ | 止まるとき | 向く処理 |
|---|---|---|---|
| サービス | HTTP リクエスト(URL がある) | リクエストが無くなると 0 まで減る | Web サイト・REST や gRPC の API・Webhook |
| ジョブ | 手動・スケジュール・Workflows | 処理が終わったら止まる | データの移行・定期の集計・大量ファイルの並列処理 |
| ワーカープール | 常に動く(URL は持たない) | 台数を手で決める(自動では増減しない) | Kafka や Pub/Sub の pull など、キューから取り出す処理 |
Cloud Run functions とは
Cloud Run functions は、関数のソースコードからデプロイされる Cloud Run のサービスです。 公式の比較のページには「関数は、ソースコードからデプロイされる Cloud Run サービスです。」と書かれています。以前の Cloud Functions(第 2 世代)が Cloud Run functions に、Cloud Functions(第 1 世代)が Cloud Run functions(第 1 世代)に名前が変わりました。
- 料金は Cloud Run の料金体系に従います(第 1 世代は別の料金体系)。
- HTTP の関数は、リクエストのタイムアウトが最大 60 分、インスタンスは最大 16 GiB のメモリと 4 vCPU、同時リクエストは 1 インスタンスあたり最大 1,000 件です。
gcloud run deployには--functionのフラグがあり、ヘルプには「デプロイするものが関数であることを指定する。値を渡すとエントリポイントとして使う」と書かれています。
サービス(コンテナで書く)
Web フレームワークごと自由に選べる
Dockerfile で OS のパッケージも入れられる
1 つのサービスに複数の URL の道筋を持てる
Cloud Run functions(関数で書く)
関数を 1 つ書けばコンテナ化は任せられる
Pub/Sub や Cloud Storage の変更などのイベントに応える
中身は Cloud Run のサービスとして動く
Cloud Runのコンテナの決まり(PORT・0.0.0.0・起動4分)
この節では、Cloud Run で動くコンテナが守る決まり(公式の「コンテナ ランタイムの契約」)が分かります。
サービスのコンテナは、環境変数 PORT のポート(既定は 8080)で、0.0.0.0 を待ち受ける必要があります。 127.0.0.1 だけで待ち受けると、外から届いたリクエストを受け取れません。
- 164 ビット Linux 向けに作るABI は Linux x86_64。マルチアーキテクチャのイメージなら linux/amd64 を含める
- 2PORT の 0.0.0.0 で待ち受けるCloud Run が Ingress のコンテナに PORT を渡す。ポート番号を決め打ちしない
- 3起動後 4 分以内に待ち受ける間に合わないとリビジョンが準備できない
- 4コンテナの中で TLS を実装しないTLS は Cloud Run が終わらせ、コンテナには HTTP/1 か gRPC で届く
- 5書いたファイルは消える前提にするファイルシステムはメモリ上。書き込みはメモリを使い、停止すると残らない
- 6SIGTERM で後片付けする止まる前に SIGTERM が届く。ログの書き出しなどをここで済ませる
Cloud Run が自動で渡す環境変数
| リソース | 環境変数 | 中身 |
|---|---|---|
| サービス | PORT(Ingress のコンテナだけ) |
待ち受けるポート |
| サービス | K_SERVICE・K_REVISION・K_CONFIGURATION |
サービス名・リビジョン名・設定名 |
| ジョブ | CLOUD_RUN_JOB・CLOUD_RUN_EXECUTION |
ジョブ名・実行の名前 |
| ジョブ | CLOUD_RUN_TASK_INDEX・CLOUD_RUN_TASK_ATTEMPT・CLOUD_RUN_TASK_COUNT |
タスクの番号(0 から)・再試行の回数(0 から)・タスクの数 |
| ワーカープール | CLOUD_RUN_WORKER_POOL・CLOUD_RUN_WORKER_POOL_REVISION |
ワーカープール名・リビジョン名 |
ほかに、ファイル記述子の上限は 25,000、メモリの上限を超えるとインスタンスは終了し処理中のリクエストは HTTP 500 で終わる、と公式に書かれています。
Cloud Run用のコンテナを手元で動かした結果(PORT・並行処理・SIGTERM)
この節では、上の決まりに沿って書いたサーバーを手元で動かし、何が起きたかが分かります。
決まりを守ったサーバーは、PORT を変えるだけで待ち受けるポートが変わり、SIGTERM を受けると後片付けのログを出して終了コード 0 で止まりました。 書いたのは次のコードです(Python の標準ライブラリだけ)。
import os, signal, sys, time, json
from http.server import BaseHTTPRequestHandler, HTTPServer, ThreadingHTTPServer
START = time.time()
PORT = int(os.environ.get("PORT", "8080")) # Cloud Run が渡す PORT で待ち受ける
HOST = os.environ.get("HOST", "0.0.0.0") # Cloud Run では 0.0.0.0(全インターフェース)
WORK = float(os.environ.get("WORK_SEC", "0")) # 1件の処理時間(並行処理の確認用)
class H(BaseHTTPRequestHandler):
def do_GET(self):
if WORK: time.sleep(WORK)
body = json.dumps({
"message": "Hello from Cloud Run style container",
"K_SERVICE": os.environ.get("K_SERVICE"),
"K_REVISION": os.environ.get("K_REVISION"),
"port": PORT,
}, ensure_ascii=False).encode()
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, fmt, *a):
print(json.dumps({"severity": "INFO", "message": fmt % a}), flush=True)
def on_sigterm(signum, frame):
print(json.dumps({"severity": "NOTICE", "message": "SIGTERM received, shutting down",
"uptime_sec": round(time.time() - START, 2)}), flush=True)
sys.exit(0)
signal.signal(signal.SIGTERM, on_sigterm)
cls = ThreadingHTTPServer if os.environ.get("THREADED", "1") == "1" else HTTPServer
srv = cls((HOST, PORT), H)
print(json.dumps({"severity": "INFO", "message": f"listening on {HOST}:{PORT}",
"server": cls.__name__}), flush=True)
srv.serve_forever()
この環境ではサーバーを 127.0.0.1 だけで動かす決まりにしているため、HOST=127.0.0.1 を渡して起動しました。Cloud Run では HOST を渡さず、既定の 0.0.0.0 で待ち受けます。K_SERVICE と K_REVISION は、Cloud Run が渡す値の代わりに手で渡しています。
$ env -i PATH=/usr/local/bin:/usr/bin:/bin HOST=127.0.0.1 PORT=28656 \
K_SERVICE=hello K_REVISION=hello-00001-abc python3 main.py &
$ curl -s -i http://127.0.0.1:28656/
HTTP/1.0 200 OK
Server: BaseHTTP/0.6 Python/3.13.18
Date: Wed, 18 Nov 2026 07:11:38 GMT
Content-Type: application/json
Content-Length: 121
{"message": "Hello from Cloud Run style container", "K_SERVICE": "hello", "K_REVISION": "hello-00001-abc", "port": 28656}
$ ss -ltnp | grep 28656
LISTEN 0 5 127.0.0.1:28656 0.0.0.0:* users:(("python3",pid=10490,fd=3))
$ kill -TERM 10490
標準出力には、1 行 1 つの JSON でログが出るようにしています。Cloud Run では、コンテナのログは Cloud Logging に自動で取り込まれます。
{"severity": "INFO", "message": "listening on 127.0.0.1:28656", "server": "ThreadingHTTPServer"}
{"severity": "INFO", "message": "\"GET / HTTP/1.1\" 200 -"}
{"severity": "NOTICE", "message": "SIGTERM received, shutting down", "uptime_sec": 0.05}
PORT と違うポートで待ち受けたとき
サーバーを 28658 で起動し、PORT として渡したつもりの 28657 に curl を送ると、つながりませんでした。Cloud Run では、この状態だとデプロイが失敗し、公式のトラブルシューティングにある Container failed to start. Failed to start and then listen on the port defined by the PORT environment variable. が出ます。
$ curl -sS http://127.0.0.1:28657/
curl: (7) Failed to connect to 127.0.0.1 port 28657 after 0 ms: Couldn't connect to server
なお、最初に選んだポートは別のプロセスが使っていて、起動時に次のエラーになりました。手元で試すときは ss -ltn で空いているポートを確かめてから選びます。
OSError: [Errno 98] Address already in use
1 件 0.5 秒の処理を同時に送ったとき
Cloud Run は 1 つのインスタンスに複数のリクエストを同時に送ります(既定は最大 80 件)。コードが同時に処理できるかで、応答の待ち時間が大きく変わります。WORK_SEC=0.5 で 1 件 0.5 秒かかるようにして、同時に 1・4・8 件を送りました。
| サーバー | 同時 1 件 | 同時 4 件 | 同時 8 件 |
|---|---|---|---|
| HTTPServer(1 件ずつ処理) | 0.50 秒 | 2.00 秒 | 4.01 秒 |
| ThreadingHTTPServer(スレッドで並行) | 0.50 秒 | 0.50 秒 | 0.51 秒 |
1 件ずつしか処理できないコードのまま同時実行数を 80 にすると、後ろのリクエストが待たされます。そうしたコードは同時実行数を 1 にするか、スレッドや非同期で並行に処理できるように直します。起動時間の 54 ミリ秒は手元のプロセスの値で、Cloud Run のコールドスタート(インスタンスの準備を含む)の時間ではありません。
この app を Cloud Run 用のイメージにする Dockerfile
手元では Docker のデーモンが動いていないため、ビルドは次のエラーで止まりました(デーモンは起動していません)。下の Dockerfile は、関連記事「Dockerfileの書き方|軽く・速く・安全なイメージを作るベストプラクティス」の書き方に合わせた最小の形です。
$ docker build -t hello-run .
ERROR: failed to connect to the docker API at unix:///var/run/docker.sock; check if the path is correct and if the daemon is running: dial unix /var/run/docker.sock: connect: no such file or directory
FROM python:3.13-slim
WORKDIR /app
COPY main.py .
ENV PYTHONUNBUFFERED=1
CMD ["python", "main.py"]
CMD を exec 形式(配列)で書くと、SIGTERM が Python に直接届きます。Docker が動く環境なら docker run -p 127.0.0.1:8080:8080 hello-run のように PORT と同じポートを手元に出して curl で確かめられます。Docker のコマンドの全体は関連記事「Dockerコマンド早見表|よく使う操作とつながらない時の対処」で扱っています。
Cloud Runの使い方:gcloud run deployでデプロイする流れ
この節では、Cloud Run にデプロイするまでの順番と、gcloud run deploy の主なフラグが分かります。
デプロイはイメージから(--image)とソースコードから(--source)の 2 通りで、どちらも gcloud run deploy 1 つで行います。 公式のクイックスタートでは、始める前にプロジェクトを選ぶか作り、課金が有効か確かめ、料金を確かめる、と書かれています。
プロジェクトと課金を用意する
Google Cloud のプロジェクトを選ぶか新しく作り、課金が有効になっているか確かめる。試すだけなら、後で消しやすいように新しいプロジェクトが勧められている。
必要なロールを確かめる
サービスに対する Cloud Run デベロッパー(roles/run.developer)、サービス ID に対するサービス アカウント ユーザー(roles/iam.serviceAccountUser)、イメージを読むための Artifact Registry 読み取り(roles/artifactregistry.reader)。
イメージを Artifact Registry に置く(--image のとき)
Google が勧める置き場所は Artifact Registry。LOCATION-docker.pkg.dev/PROJECT_ID/REPO_NAME/PATH:TAG の形で指定し、リポジトリは先に作っておく。
gcloud run deploy を実行する
サービス名・イメージ(またはソース)・リージョンを指定する。公開するかどうかを聞かれたら決める。
URL を開いて確かめ、不要になったら消す
表示された URL を開く。試したあとは gcloud run services delete SERVICE --region REGION でサービスを消し、イメージのリポジトリも消す(保存しているあいだ料金がかかる)。
コマンドの形は次のとおりです(公式のドキュメントとヘルプの例。この記事では実行していません)。
# イメージからデプロイする
gcloud run deploy SERVICE --image LOCATION-docker.pkg.dev/PROJECT_ID/REPO/IMAGE:TAG --region asia-northeast1
# ソースコードからデプロイする(Dockerfile があればそれで、なければ Buildpack でビルド)
gcloud run deploy SERVICE --source . --region asia-northeast1
# 設定をまとめて渡す例
gcloud run deploy SERVICE --image IMAGE_URL \
--region asia-northeast1 --memory 512Mi --cpu 1 \
--concurrency 80 --timeout 300 --min 0 --max 3
コンソールでは、「Cloud Run」のページで「サービス」を選び、「コンテナをデプロイ」を押して、「コンテナ イメージの URL」「サービス名」「リージョン」「認証」を入れて「作成」を押す流れです。
gcloud run deploy の主なフラグ(ヘルプの表示から)
ログインしていない gcloud で gcloud run deploy --help を表示し、記事で使うフラグを確かめました。gcloud auth list は次のとおりで、この環境では認証情報を持っていません。
$ gcloud auth list
No credentialed accounts.
To login, run:
$ gcloud auth login `ACCOUNT`
$ gcloud run deploy --help
NAME
gcloud run deploy - create or update a Cloud Run service
| フラグ | 働き(ヘルプの説明) |
|---|---|
--image |
デプロイするコンテナイメージ。--source と一緒なら Artifact Registry の URI でサービス名と同じ名前 |
--source |
ビルドするソースの場所。Dockerfile があれば使い、無ければ Google Cloud の Buildpack |
--port |
リクエストを受けるコンテナのポート。$PORT も同じ値になる(1〜65535) |
--concurrency |
1 インスタンスあたりの同時リクエストの上限。省略するとサーバーの既定値 |
--min・--max |
サービス全体のインスタンス数の下限・上限。新しいリビジョンを作らずに変えられる |
--min-instances・--max-instances |
リビジョンごとの下限・上限。変えると新しいリビジョンがデプロイされる |
--[no-]cpu-boost |
起動時に CPU を多めに割り当ててコールドスタートを短くする。新しいサービスでは省略時に有効 |
--[no-]cpu-throttling |
リクエストを処理していないときに CPU を絞るか。--no-cpu-throttling はインスタンスベースの課金 |
--timeout |
リクエストの最大処理時間。単位が無ければ秒(例:10m5s) |
--[no-]allow-unauthenticated |
認証なしの呼び出しを許すか。省略するとデプロイ時に確かめられる |
--[no-]invoker-iam-check |
呼び出し元の IAM の確かめを外すか(公開のもう 1 つの方法) |
サービス名は 49 文字以下で、リージョンとプロジェクトごとに一意にし、後から変えられません。タグ付きのイメージはデプロイ時にダイジェストに固定され、新しいインスタンスの起動のたびにレジストリから取り直すことはありません。
Cloud Runの同時実行・最小インスタンス・コールドスタート
この節では、インスタンスの増え方を決める設定と、最初の応答が遅くなる理由と対策が分かります。
インスタンスが 0 のときに来た最初のリクエストは、インスタンスの起動を待つため遅くなります(コールドスタート)。 避けたいときは最小インスタンス数を 1 以上にしますが、その分の料金がかかります。
| 設定 | 既定値 | 上限・範囲 | 決め方 |
|---|---|---|---|
| 同時実行数(concurrency) | 80 | 1,000 | 1 件で CPU・メモリの大半を使う、共有できない状態に頼るなら 1 |
| 最小インスタンス数 | 0 | — | コールドスタートを避けたいなら 1 以上(アイドルでも料金) |
| 最大インスタンス数 | リビジョンごとに 100 | 引き上げを申請できる | 費用やデータベースの接続数を抑える。公式は急増への備えに 3 の例 |
| リクエストのタイムアウト | 5 分(300 秒) | 60 分(3,600 秒) | 超えると 504 |
| CPU・メモリ | 1 vCPU・512 MiB | 8 vCPU・32 GiB | インスタンスベースの課金は 512 MiB 以上 |
ソースからデプロイしたコードを並行に動かすときは、公式は「少ない数(8 など)から同時実行を始めて、その数を増やしていく」ことを勧めています。Python なら同時実行数に合わせてスレッド数を決めます(例:THREADS=8)。
コールドスタートを短くする方法(公式のヒント)
- 1起動時の CPU ブーストを使う起動のあいだだけ CPU を増やす。新しいサービスでは既定で有効(--cpu-boost)
- 2依存ライブラリを減らす数と大きさを小さくし、あまり使わないコードの読み込みを遅らせる
- 3あまり使わないものは後で初期化するただし最初のリクエストが遅くなるので、アクセスが多いときは注意
- 4最小インスタンス数を 1 以上にする起動を待たずに応答できる。アイドルの料金がかかる
- 5実行環境(第 1 世代・第 2 世代)を変えてみる起動時間が短くなる場合がある
公式のヒントには、イメージの大きさはイメージのストリーミングの仕組みにより起動時間に影響しない、とも書かれています。AWS Lambda のコールドスタート対策は、関連記事「Lambdaコールドスタート対策|SnapStartとプロビジョンド同時実行の比較」で扱っています。
Cloud Runの料金と無料枠(2026年11月18日時点)
この節では、Cloud Run の料金がどう決まるかと、Tier 1 の単価・無料枠が分かります。
サービスの料金は、リクエストベース(既定)とインスタンスベースの 2 つの課金から選びます。 リクエストベースはインスタンスの起動中・停止の処理中・リクエストの処理中だけが課金され、リクエストの件数にも料金がかかります。インスタンスベースはインスタンスがある間ずっと課金され(最低 1 分)、件数の料金はかかりません。課金の時間は 100 ミリ秒単位に切り上げられます。
| 項目(Tier 1・米ドル) | リクエストベース | インスタンスベース | ジョブ |
|---|---|---|---|
| CPU(1 vCPU 秒) | $0.000024(処理中) | $0.000018 | $0.000018 |
| メモリ(1 GiB 秒) | $0.0000025(処理中) | $0.000002 | $0.000002 |
| アイドル(最小インスタンス) | CPU $0.0000025・メモリ $0.0000025 | — | — |
| リクエスト(100 万件) | $0.40 | なし | — |
| 毎月の無料枠 | 180,000 vCPU 秒・360,000 GiB 秒・200 万件 | 240,000 vCPU 秒・450,000 GiB 秒 | 240,000 vCPU 秒・450,000 GiB 秒 |
- 東京(asia-northeast1)と大阪(asia-northeast2)は Tier 1 の料金のリージョンです。
- 無料枠は us-central1 の料金を基準にした支出ベースの割引で、請求先アカウントごとにプロジェクトをまとめて集計し、毎月リセットされます。
- 最小インスタンスとして保たれているインスタンスだけがアイドルの料金の対象で、それ以外のアイドルのインスタンスには料金がかかりません。
- インターネットへのデータ転送は Google Cloud のネットワークの料金で、北米内は毎月 1 GiB まで無料です。同じリージョンの Google Cloud のリソースへの転送は無料です。
- ワーカープールは CPU $0.000011244/vCPU 秒・メモリ $0.000001235/GiB 秒、確約利用割引(1 年・3 年)もあります。円での支払いは、SKU に書かれた通貨の料金が使われます。
料金はよく変わるため、使う前に公式の料金のページと料金計算ツールで確かめます。
Cloud Runの料金をPythonで試算した結果
この節では、月のリクエスト数と処理時間から、いくらかかるかを計算した結果が分かります。
1 件 0.2 秒・1 vCPU・512 MiB なら、月 100 万件でも $0.48、リクエストが重なれば無料枠に収まりました。 上の単価と無料枠をそのまま使い、次のスクリプトで計算しています(ネットワークの転送とイメージの保存は含みません)。
CPU_ACT, MEM_ACT, REQ = 0.000024, 0.0000025, 0.40/1_000_000 # リクエストベース(処理中)
CPU_IDLE, MEM_IDLE = 0.0000025, 0.0000025 # 最小インスタンスのアイドル
CPU_INS, MEM_INS = 0.000018, 0.000002 # インスタンスベース
FREE_REQ = dict(cpu=180_000, mem=360_000, req=2_000_000)
FREE_INS = dict(cpu=240_000, mem=450_000)
MONTH = 30*24*3600
def req_based(reqs, sec, vcpu, gib, overlap=1):
t = reqs*sec/overlap # 課金対象のインスタンス時間(秒)
c = max(0, t*vcpu-FREE_REQ['cpu'])*CPU_ACT
m = max(0, t*gib-FREE_REQ['mem'])*MEM_ACT
r = max(0, reqs-FREE_REQ['req'])*REQ
return t, c, m, r, c+m+r
「重なり」は、同じインスタンスで平均いくつのリクエストが同時に処理されているかです。リクエストベースの課金時間は「最初のリクエストの開始から最後のリクエストの終了まで」なので、重なるほど課金時間が短くなります。重なり 1 は、まったく重ならない場合の上限の見積もりです。
| 月の件数 | 重なり | 課金時間 | CPU・メモリ | 合計 |
|---|---|---|---|---|
| 10 万件 | 1 | 20,000 秒 | $0.00 | $0.00 |
| 100 万件 | 1 | 200,000 秒 | $0.48 | $0.48 |
| 100 万件 | 4 | 50,000 秒 | $0.00 | $0.00 |
| 300 万件 | 1 | 600,000 秒 | $10.08 | $10.48 |
| 300 万件 | 4 | 150,000 秒 | $0.00 | $0.40 |
| 1,000 万件 | 1 | 2,000,000 秒 | $45.28 | $48.48 |
| 1,000 万件 | 4 | 500,000 秒 | $7.68 | $10.88 |
合計と CPU・メモリの差は、200 万件を超えた分のリクエストの料金です(300 万件で $0.40、1,000 万件で $3.20)。
常に動かす場合と、最小インスタンスの料金
| 置き方(1 vCPU・512 MiB・30 日) | 計算 | 月の額 |
|---|---|---|
| インスタンスベースで 1 台を動かし続ける | CPU $42.34+メモリ $1.69(無料枠を引いた後) | $44.03 |
| リクエストベースで最小インスタンス 1 がずっとアイドル | 2,592,000 秒 ×($0.0000025+0.5×$0.0000025) | $9.72(無料枠を引く前) |
1 秒あたりの単価を比べると、処理中のリクエストベースは $0.00002525、インスタンスベースは $0.00001900 でした。インスタンスが 75.2% 以上の時間リクエストを処理しているなら、インスタンスベースのほうが安くなる計算です(無料枠とリクエストの料金を除いた比較)。公式も、トラフィックが安定していてアイドルが少ない場合はインスタンスベースが安くなることがある、と説明しています。
Cloud Runジョブの使い方(タスクで分けて並列に処理する)
この節では、ジョブの作り方と、タスクごとに担当を分ける書き方が分かります。
ジョブは、同じコンテナを複数のタスクとして動かし、各タスクが CLOUD_RUN_TASK_INDEX を見て自分の担当分だけを処理します。 終わったら終了コード 0、失敗なら 0 以外で終わり、Web サーバーは起動しません。
import os, sys
items = [f"img_{i:02d}.png" for i in range(10)] # 処理したいファイルが10個ある想定
idx = int(os.environ.get("CLOUD_RUN_TASK_INDEX", "0")) # 0 から始まる
cnt = int(os.environ.get("CLOUD_RUN_TASK_COUNT", "1"))
mine = items[idx::cnt] # 自分の担当分だけ取る
print(f"task {idx}/{cnt} attempt={os.environ.get('CLOUD_RUN_TASK_ATTEMPT','0')} -> {mine}")
if os.environ.get("FAIL") == "1":
print("error: input not found", file=sys.stderr); sys.exit(1) # 失敗は 0 以外で終わる
sys.exit(0)
Cloud Run が渡す環境変数を手で渡し、タスク 3 つで動かした結果です。10 個のファイルが重なりなく分かれました。
task 0/3 attempt=0 -> ['img_00.png', 'img_03.png', 'img_06.png', 'img_09.png']
exit=0
task 1/3 attempt=0 -> ['img_01.png', 'img_04.png', 'img_07.png']
exit=0
task 2/3 attempt=0 -> ['img_02.png', 'img_05.png', 'img_08.png']
exit=0
error: input not found
task 1/3 attempt=1 -> ['img_01.png', 'img_04.png', 'img_07.png']
exit=1
ジョブを作るコマンドは次の形です(公式の記載。実行していません)。
gcloud run jobs create JOB_NAME --image IMAGE_URL --tasks 3 --max-retries 3 --task-timeout 10m
# 作成と更新をまとめて行う形
gcloud run jobs deploy JOB_NAME --image IMAGE_URL
| ジョブの設定 | 既定値 | 上限 |
|---|---|---|
--tasks(タスクの数) |
1 | ジョブあたり 10,000 |
--task-timeout |
10 分 | 168 時間(7 日。24 時間を超える設定はプレビュー) |
--max-retries |
3 | 10 |
--parallelism |
タスクは並列で開始される | リージョン・CPU・メモリで変わる |
並列にすると、タスクは番号の順に始まるとは限りません。タイムアウトになると SIGTERM が届き、約 10 秒後に SIGKILL で止められます。ジョブはインスタンスベースの単価で、最低 1 分課金されます。
Cloud RunとLambda・ECSの違い
この節では、AWS の Lambda・ECS と比べたときの違いが分かります。
Cloud Run はコンテナをそのまま HTTP のサービスにでき、1 回のリクエストを最大 60 分まで処理できます。 Lambda は関数単位で最大 15 分、ECS はクラスター・タスク定義・サービスを組み合わせてコンテナを動かします。優劣ではなく、作り方と上限の違いです。
| 項目 | Cloud Run(サービス) | AWS Lambda | Amazon ECS(Fargate) |
|---|---|---|---|
| 動かす単位 | コンテナ(ソースからも可) | 関数(zip かコンテナイメージ) | タスク定義に書いたコンテナ |
| 処理時間の上限 | リクエストのタイムアウト 60 分 | 関数のタイムアウト 900 秒(15 分) | サービスは長く動き続け、タスクは処理を終えると止まる |
| メモリ | 最大 32 GiB・8 vCPU | 128〜10,240 MB | タスクの設定による |
| 1 回の受け渡し | HTTP/1 は 32 MiB(HTTP/2 は無制限) | 同期の呼び出しは 6 MB | アプリと前段の設定による |
| 課金の単位 | 100 ミリ秒に切り上げ | リクエスト数と実行時間(GB 秒) | 秒単位・Linux は最低 1 分 |
Lambda のコンテナイメージは最大 10 GB(展開後)です。ECS は、コンテナが動く「キャパシティ」、デプロイと管理の「コントローラー」、操作の「プロビジョニング」の 3 層で説明され、キャパシティには Fargate・EC2 などを選べます。Lambda と ECS のそれぞれの入門は「AWS Lambdaとは|仕組み・料金の計算・できることと向かない処理」「Amazon ECSとは|Fargateとの関係・料金・タスクとサービスの仕組み」で扱います。Kubernetes でコンテナを動かす書き方は、関連記事「Kubernetes入門|主要リソースとYAMLの書き方、kubectl早見表」で扱っています。
PORT の扱い
手元でも PORT を変えて起動し、そのポートに curl が通るかで確かめる
Cloud Runの主な上限値と既定値
この節では、設計の前に知っておく上限の数字が一覧で分かります。
上限の多くは、プロジェクトとリージョンごとに決まっています。 公式の「割り当てと上限」のページの値です。
| 項目 | 上限 |
|---|---|
| メモリ・vCPU(インスタンス) | 32 GiB・8 vCPU |
| 起動のタイムアウト | 4 分 |
| 同時リクエスト(インスタンスあたり) | 1,000 |
| リクエストのタイムアウト | 60 分 |
| HTTP/1 のリクエスト・レスポンスの大きさ | 32 MiB(レスポンスはストリーミングなしの場合) |
| 環境変数 | コンテナあたり 1,000 個・値は 32 KB まで |
| サービス数・ジョブ数 | プロジェクトとリージョンごとに各 1,000 |
| サービスごとのリビジョン数 | 1,000 |
| 帯域幅 | インスタンスあたり 600 Mbps(ダイレクト VPC の外向きは 1 Gbps) |
| コンテナイメージの大きさ | 直接の上限はない(Docker Hub など外部経由は 9.9 GB を超えるレイヤーに非対応) |
Cloud Runでよくあるエラーとつまずき(原文つき)
この節では、デプロイや呼び出しで出るエラーの文言と、原因・直し方が分かります。
いちばん多いのは、PORT で待ち受けていないためにコンテナが起動しないエラーです。 文言は公式のトラブルシューティングのページの英語のままです。
| 表示(原文) | 原因 | 直し方 |
|---|---|---|
Container failed to start. Failed to start and then listen on the port defined by the PORT environment variable. |
PORT で待ち受けていない・127.0.0.1 だけで待ち受けている | PORT を読み 0.0.0.0 で待ち受ける。手元で PORT を変えて起動し curl で確かめる |
Revision REVISION_NAME is not ready and cannot serve traffic. |
Python のソースデプロイで、Buildpack の既定の起動方法が合わない | requirements.txt に gunicorn などを足す。GOOGLE_ENTRYPOINT か Procfile で起動方法を決める |
HTTP 403: The request was not authenticated. Either allow public access or set the proper Authorization header |
公開していないサービスを、認証なしで呼んだ | 公開するか、呼び出し元に roles/run.invoker を付け、正しい Authorization ヘッダーで呼ぶ |
The request was aborted because there was no available instance.(429) |
最大インスタンス数に届いた・増え方が追いつかない | 最大インスタンス数を増やす・同時実行数を見直す・呼ぶ側で間隔を空けて再試行する |
The request failed because the instance could not start successfully.(500) |
決まった時間内に起動しない。Secret Manager のシークレットを読めないことが多い | シークレットの名前・版と、読み取りのロールを確かめる。起動のログを足す |
The request has been terminated because it has reached the maximum request timeout.(504) |
リクエストのタイムアウトまでに応答が返らなかった | --timeout を延ばす(最大 60 分)。遅い処理はジョブに分ける |
While handling this request, the container instance was found to be using too much memory and was terminated. |
メモリの上限を超えた。メモリ上のファイルへの書き込みも含む | --memory を上げる。一時ファイルを大量に書かない |
curl: (7) Failed to connect to 127.0.0.1 port 28657(手元) |
手元で起動したポートと、送ったポートが違う | ss -ltn で待ち受けているポートを見て、PORT と揃える |
ほかにも、ARM ベースのマシンでビルドしたイメージは Cloud Run で意図どおり動かないことがある、と公式に書かれています。64 ビット Linux(linux/amd64)向けにビルドするか、Cloud Build でビルドします。
判断表:Cloud Runを選ぶ場面・ほかを選ぶ場面
この節では、作りたいものに対して Cloud Run のどの形を選ぶかが分かります。
HTTP で呼ばれるものはサービス、終わりのある処理はジョブ、キューを読み続けるものはワーカープールが基本です。
| 作りたいもの | 選ぶもの | 設定の目安 |
|---|---|---|
| アクセスが少ない社内ツール・試作の API | サービス(リクエストベース) | 最小 0。無料枠に収まりやすい |
| 最初の応答を速くしたい API | サービス+最小インスタンス 1 | アイドルの料金(試算では月 $9.72)を見込む |
| 一日中ほぼ休まず処理している API | サービス(インスタンスベース) | 稼働率 75% 以上で安くなる計算 |
| Pub/Sub・Cloud Storage のイベントで動く小さな処理 | Cloud Run functions | 関数のソースからデプロイ |
| 夜間の集計・大量ファイルの変換 | ジョブ | タスクに分け、TASK_INDEX で担当を分ける |
| Kafka・Pub/Sub の pull を読み続ける処理 | ワーカープール | 台数を手で決める |
| 1 回 60 分を超える HTTP の処理 | サービスでは受けない | ジョブ(タスク最大 168 時間)に分ける |
よくある質問
Q. Cloud Run とは何ですか?
A. Google Cloud の、コード・関数・コンテナを動かすフルマネージドの実行基盤です。コンテナイメージかソースコードを渡すと URL が付き、リクエストに応じてインスタンスが増減します。
Q. Cloud Run は無料で使えますか?
A. 毎月の無料枠があります。リクエストベースのサービスでは 180,000 vCPU 秒・360,000 GiB 秒・200 万リクエストです。超えた分は課金され、課金を有効にしたプロジェクトが必要です(2026年11月18日時点)。
Q. Cloud Run の料金はどう計算しますか?
A. リクエストベースなら「処理中の時間 × vCPU × 単価」「処理中の時間 × GiB × 単価」「件数 × 単価」の合計から無料枠を引きます。この記事の試算では、1 件 0.2 秒・1 vCPU・512 MiB で月 100 万件が $0.48 でした。
Q. Cloud Run と Cloud Functions の違いは何ですか?
A. Cloud Functions(第 2 世代)は Cloud Run functions に名前が変わり、関数は Cloud Run のサービスとしてデプロイされます。関数で書くか、コンテナで書くかの違いです。
Q. Docker が無くても Cloud Run にデプロイできますか?
A. できます。gcloud run deploy --source . を使うと、Dockerfile があればそれで、無ければ Google Cloud の Buildpack でビルドされます。
Q. Cloud Run のポートは何番ですか?
A. 既定では 8080 にリクエストが送られ、環境変数 PORT に入ります。--port で変えられます。コードは PORT を読み、0.0.0.0 で待ち受けます。
Q. コールドスタートを無くせますか?
A. 最小インスタンス数を 1 以上にすると、起動を待たずに応答できます。ただしアイドルの料金がかかります。起動時の CPU ブーストや依存を減らすことでも短くできます。
Q. Cloud Run でファイルを保存できますか?
A. コンテナのファイルシステムはメモリ上にあり、インスタンスが止まると消えます。残すファイルは Cloud Storage との統合や NFS のマウントを使います。
Q. 1 回のリクエストは何分まで処理できますか?
A. 既定は 5 分、最大 60 分です。もっと長い処理はジョブに分けると、タスクごとに最大 168 時間まで動かせます。
Q. 東京リージョンは使えますか?料金は高いですか?
A. 東京は asia-northeast1 で、料金は Tier 1 です。--region asia-northeast1 で指定します。
Q. 料金の上限を決めておけますか?
A. 最大インスタンス数で増え方を抑えられます。公式は、予期しない急増から予算を守るために 3 にする例を挙げています。
まとめ
- Cloud Run は、コンテナかソースコードを渡すと URL が付いて動き、リクエストに応じて 0 から増減する Google Cloud のサービス。
- 形はサービス(HTTP)・ジョブ(終わる処理)・ワーカープール(常に動く処理)の 3 つ。Cloud Run functions はソースからデプロイしたサービス。
- コンテナは PORT(既定 8080)の 0.0.0.0 で待ち受け、4 分以内に起動する。手元で PORT を変えて curl すると、違うポートでは
curl: (7)になった。 - 料金はリクエストベース(処理中だけ)とインスタンスベース(ずっと)。試算では稼働率 75% 以上でインスタンスベースが安く、月 100 万件・0.2 秒なら $0.48。
- 同時実行は既定 80。1 件ずつしか処理できないコードでは 8 件の同時送信で 4.01 秒かかったので、並行に処理できるように直すか同時実行数を下げる。
参考・出典
確認日:2026年11月18日
- Google Cloud「Cloud Run とは」:https://docs.cloud.google.com/run/docs/overview/what-is-cloud-run?hl=ja
- Google Cloud「コンテナ ランタイムの契約」:https://docs.cloud.google.com/run/docs/container-contract?hl=ja
- Google Cloud「Cloud Run の料金」:https://cloud.google.com/run/pricing?hl=ja
- Google Cloud「サービスのデプロイ」:https://docs.cloud.google.com/run/docs/deploying?hl=ja
- Google Cloud「クイックスタート:コンテナをデプロイする」:https://docs.cloud.google.com/run/docs/quickstarts/deploy-container?hl=ja
- Google Cloud「gcloud run deploy」リファレンス:https://docs.cloud.google.com/sdk/gcloud/reference/run/deploy
- Google Cloud「同時実行について」:https://docs.cloud.google.com/run/docs/about-concurrency?hl=ja
- Google Cloud「最小インスタンス数」:https://docs.cloud.google.com/run/docs/configuring/min-instances?hl=ja
- Google Cloud「最大インスタンス数」:https://docs.cloud.google.com/run/docs/configuring/max-instances?hl=ja
- Google Cloud「リクエストのタイムアウト」:https://docs.cloud.google.com/run/docs/configuring/request-timeout?hl=ja
- Google Cloud「課金の設定」:https://docs.cloud.google.com/run/docs/configuring/billing-settings?hl=ja
- Google Cloud「一般的な開発のヒント」:https://docs.cloud.google.com/run/docs/tips/general?hl=ja
- Google Cloud「ジョブを作成する」:https://docs.cloud.google.com/run/docs/create-jobs?hl=ja
- Google Cloud「Cloud Run functions の比較」:https://docs.cloud.google.com/run/docs/functions/comparison?hl=ja
- Google Cloud「割り当てと上限」:https://docs.cloud.google.com/run/quotas?hl=ja
- Google Cloud「トラブルシューティング」:https://docs.cloud.google.com/run/docs/troubleshooting
- AWS「Lambda quotas」:https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-limits.html
- AWS「What is Amazon Elastic Container Service?」:https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html
- AWS「AWS Fargate Pricing」:https://aws.amazon.com/fargate/pricing/
本記事の内容は、ご自由にお使いください。
ご利用の際は、出典として本ページへのリンクを記載いただけますようお願いします。
(記載例)出典:株式会社RJC「Cloud Runとは|使い方・料金の試算・コンテナをデプロイする流れ」
株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。
WE ARE HIRING
RJCで一緒に開発しながら、
成長を楽しみませんか?
RJCは、Web・モバイル・AIを活用した開発プロジェクトで、テックリードやPM・PMOも活躍するシステム開発会社です。会社を知る、待遇を確かめる、話を聞いてみる。気になるところ見てみてください!
- 127日年間休日
- 12時間平均残業時間
- 毎日ガチャ遊びココロも大切にする福利厚生。アマギフなどの賞品ラインナップ!
ほかにも、チケットレストラン、書籍読み放題、2年ごとの慰労報奨(休暇 or 金一封)、11期連続の黒字決算。