Skip to main content
Console
CloudBase Run

Bring your containers,
let the platform run them.

A cloud-native app engine for containerized apps in any language or framework. Autoscale — including scale to zero — with WebSocket and SSE, deeply integrated with CloudBase Database and Storage.

Go to CloudRun consoleRead CloudRun docs
Container · Autoscale · WebSocket
cloudrun / servicesrunning
production
service

api-server

Node.js · HTTP · v3

service

ml-inference

Python · HTTP · v2

service

realtime-ws

Go · WebSocket · v1

service · versioninstancesstate
api-server · v33 → autohealthy
ml-inference · v21 → autohealthy
realtime-ws · v12 → fixedconnected
From Dockerfile to production

Every deploy creates a version; traffic splits flexibly across versions

Build the image, create a version, and split traffic — three steps to ship. Flip traffic when the new version checks out; roll back instantly if something goes wrong.

deploy pipelinerevision created
01 · Build

Build container image

Dockerfile · any language

→
02 · Deploy

Create a new version

Service · Revision · Instance

→
03 · Route

Traffic splitting

Canary · version switch · rollback

revisiontrafficstate
api-server-v390%stable
api-server-v410%canary
api-server-v20%standby

Full runtime primitives for shipping containers

From any-language runtimes to autoscaling, long-lived connections, and continuous delivery — configure for the workload you have.

01

Any language and framework

Containerize and deploy — Node.js, Python, Go, Java, PHP, .NET, or any runtime you can put in a Dockerfile.

CONTAINER
02

Autoscaling and scale to zero

Instances scale with real load — scale to zero with no compute cost when idle, expand automatically at peak.

AUTOSCALE
03

WebSocket / SSE / long-lived connections

Native HTTP, WebSocket, and SSE — ready for realtime chat, streaming output, and AI inference responses.

REALTIME
04

Service / version / canary

Each deploy creates an immutable version; split traffic by ratio for canary release, A/B tests, and fast rollback.

REVISION
05

Multiple deploy methods

Deploy from source, images, Git triggers, or the CLI — plug into GitHub, GitLab, or Gitee for continuous delivery.

DEPLOY
06

Logs and monitoring

Stream container stdout; monitor QPS, latency, CPU, and memory — unhealthy instances restart automatically and report health.

OBSERVABILITY
“
Container hosting is not about storing a Dockerfile in the cloud — it moves the team's focus from server lifecycles back to versions, traffic splitting, and business outcomes.
Product design principle
Any language, one platform

You pick the language and framework; the platform handles ops

No separate runtimes per language — once containerized, Node.js, Python, Go, and Java share the same autoscaling and observability stack.

View quick start
RUNTIME CHOICE
Node.js / GoWeb services / APIs
PythonAI inference / data
Java / .NETEnterprise app migration
PHP / RubyExisting apps to cloud

From Dockerfile to continuously shippable services

Examples follow real deploy paths from the docs — container definitions, multi-language support, and CLI deploys.

Node.js container

Define a Node.js service runtime with a Dockerfile

Apps listen on the PORT env var; stdout lands in service logs; fixed build artifacts make version tracking and rollback straightforward.

  • PORT is injected by the platform as an env var
  • CMD sets the process entry; the platform handles health checks
  • Multi-stage builds keep image size down
Dockerfile
FROM node:22-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev

COPY . .
ENV PORT=8080
EXPOSE 8080

CMD ["node", "server.js"]
Python / FastAPI container

The same mechanism hosts Python AI services

FastAPI supports SSE and WebSocket natively — fit for AI inference, streaming responses, and realtime chat without framework changes.

  • Any Python version; manage deps with requirements.txt
  • uvicorn listens on PORT; works with ASGI frameworks
  • Shares the same environment as CloudBase Database and Storage
Dockerfile.python
FROM python:3.12-slim

WORKDIR /app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

COPY . .
ENV PORT=8080
EXPOSE 8080

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]
CLI deployment

Debug locally and deploy to CloudRun with the tcb CLI

tcb cloudrun covers init, local run, and deploy — wire it into CI/CD instead of manual steps.

  • tcb cloudrun init sets up service config
  • tcb cloudrun run validates container behavior locally
  • tcb cloudrun deploy triggers a source deploy
deploy.sh
# Log in to CloudBase
tcb login

# Initialize a CloudRun service
tcb cloudrun init my-service --port=8080

# Run locally to debug
tcb cloudrun run

# Deploy
tcb cloudrun deploy
CloudRun ecosystem

Containers deeply integrated with CloudBase resources

CloudRun services reach CloudBase Database, Storage, and VPC resources like MySQL and Redis over the private network.

01

Web apps and API services

RESTful APIs, microservices, corporate sites, and SaaS backends.

02

Realtime and AI apps

WebSocket services, SSE push, model inference, and AI customer support.

03

Scheduled jobs and data processing

Report generation, data sync, and periodic cleanup jobs.

Node.jsPythonGoJavaPHP.NETDockerDockerfileWebSocketSSEAutoscaleRevisionCanary ReleaseGitHubGitLabGiteeCI/CDVPC
Run your container

Containerize existing apps; plug into autoscaling and continuous delivery

Write a Dockerfile, push code, or upload an image — CloudRun handles the rest.

Go to CloudRunView deploy guide